fix(mistral): refactoring structurel complet du provider Mistral

- is_configured() vérifie maintenant que mistralai>=1.0 est importable
(from mistralai import Mistral) ; retourne False si v0.x est installé
ou si le package est absent, rendant le provider invisible dans l'UI

- list_models() devient dynamique via client.models.list() (SDK v1.x) :
retourne tous les modèles génératifs sauf embeddings/modération ;
fallback statique (Pixtral Large + 12B) si l'API est inaccessible

- _model_supports_vision() nouveau helper : utilise capabilities.vision
en priorité, se rabat sur la présence de "pixtral"/"vision" dans l'ID

- generate_content() bifurque selon le support vision du modèle :
content multimodal image_url+text pour Pixtral,
string prompt seul pour Mistral Large/Small/Codestral

- Dockerfile : layer dédié `pip install 'mistralai>=1.0,<2.0'` pour
invalider le cache HuggingFace Spaces qui conservait v0.x

- pyproject.toml : version 0.2.0 + contrainte mistralai>=1.0 explicite

- Tests : réécriture complète avec faux SDK (FakeCaps, FakeModel,
FakeModelsAPI, _make_fake_mistralai), 20+ tests couvrant tous les
scénarios : v0.x détecté, API dynamique, fallback statique, bifurcation
vision/texte, backward-compat alias _MISTRAL_VISION_MODELS

https://claude.ai/code/session_018woyEHc8HG2th7V4ewJ4Kg

backend/app/services/ai/provider_mistral.py

@@ -1,18 +1,26 @@
 """
 Provider Mistral — authentification via MISTRAL_API_KEY.
 
-Modèles multimodaux supportés : pixtral-large-latest, pixtral-12b-2409.
-L'API Mistral n'expose pas d'endpoint list_models public stable ;
-la liste des modèles est donc statique et maintenue ici.
-
-Les appels image utilisent le format image_url (base64) dans le message user.
+Découverte dynamique des modèles via client.models.list() (SDK v1.x).
+Fallback statique sur Pixtral Large + 12B si l'API est inaccessible.
+
+is_configured() vérifie AUSSI que `from mistralai import Mistral` fonctionne.
+Si seule la version 0.x est installée, le provider est marqué indisponible :
+l'utilisateur ne peut pas sélectionner de modèle Mistral, et aucun job
+ne partira avec une clé incompatible.
+
+Bifurcation d'appel selon la capacité vision du modèle :
+  - Pixtral (capabilities.vision = True, ou "pixtral" dans l'id) :
+      content multimodal — image base64 + texte.
+  - Modèles texte (Mistral Large, Small, Codestral…) :
+      content texte seul — l'image n'est pas transmise.
 """
 # 1. stdlib
 import base64
 import logging
 import os
 
-# 3. local  (mistralai importé localement pour éviter l'import top-level à froid)
+# 3. local
 from app.schemas.model_config import ModelInfo, ProviderType
 from app.services.ai.base import AIProvider
 
@@ -20,7 +28,11 @@ logger = logging.getLogger(__name__)
 
 _ENV_KEY = "MISTRAL_API_KEY"
 
-_MISTRAL_VISION_MODELS: list[ModelInfo] = [
+# Sous-chaînes d'IDs de modèles non génératifs à exclure de la liste
+_SKIP_MODEL_KINDS = ("embed", "moderation")
+
+# Liste statique de secours — utilisée si client.models.list() échoue
+_MISTRAL_FALLBACK_MODELS: list[ModelInfo] = [
     ModelInfo(
         model_id="pixtral-large-latest",
         display_name="Pixtral Large",
@@ -39,12 +51,30 @@ _MISTRAL_VISION_MODELS: list[ModelInfo] = [
     ),
 ]
 
+# Alias backward-compat (utilisé dans certains tests)
+_MISTRAL_VISION_MODELS = _MISTRAL_FALLBACK_MODELS
+
+
+def _model_supports_vision(model_id: str, model_obj: object = None) -> bool:
+    """Détecte si un modèle Mistral supporte les entrées image.
+
+    Utilise capabilities.vision si disponible (objet SDK v1.x),
+    sinon se rabat sur la présence de 'pixtral' ou 'vision' dans l'ID.
+    """
+    if model_obj is not None:
+        caps = getattr(model_obj, "capabilities", None)
+        if caps is not None:
+            return bool(getattr(caps, "vision", False))
+    mid = model_id.lower()
+    return "pixtral" in mid or "vision" in mid
+
 
 class MistralProvider(AIProvider):
     """Provider Mistral AI (clé API MISTRAL_API_KEY).
 
-    Liste de modèles statique (Pixtral Large + Pixtral 12B).
-    Les appels image encodent le JPEG en base64 et l'envoient comme image_url.
+    is_configured() valide à la fois la présence de MISTRAL_API_KEY ET
+    que mistralai>=1.0 (classe Mistral) est importable. Si v0.x est installée,
+    le provider est marqué indisponible pour éviter des jobs voués à l'échec.
     """
 
     @property
@@ -52,58 +82,109 @@ class MistralProvider(AIProvider):
         return ProviderType.MISTRAL
 
     def is_configured(self) -> bool:
-        return bool(os.environ.get(_ENV_KEY))
+        """Retourne True si MISTRAL_API_KEY est définie ET mistralai>=1.0 est importable."""
+        if not os.environ.get(_ENV_KEY):
+            return False
+        try:
+            from mistralai import Mistral  # noqa: F401
+            return True
+        except ImportError:
+            logger.warning(
+                "MISTRAL_API_KEY est définie mais mistralai>=1.0 n'est pas disponible "
+                "(version 0.x détectée ou package absent). "
+                "Provider Mistral marqué indisponible. "
+                "Reconstruisez le container : docker build --no-cache ..."
+            )
+            return False
 
     def list_models(self) -> list[ModelInfo]:
+        """Liste les modèles Mistral disponibles via l'API (dynamique).
+
+        Appelle client.models.list() pour récupérer la liste réelle.
+        Filtre les modèles non génératifs (embeddings, modération).
+        Utilise capabilities.vision pour déterminer le support image.
+        Fallback sur la liste statique Pixtral si l'API est inaccessible.
+        """
         if not self.is_configured():
-            raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
+            raise RuntimeError(
+                f"Provider Mistral non configuré : vérifiez {_ENV_KEY} "
+                "et que mistralai>=1.0 est installé."
+            )
+
+        from mistralai import Mistral
+
+        client = Mistral(api_key=os.environ[_ENV_KEY])
+        result: list[ModelInfo] = []
+
+        try:
+            models_resp = client.models.list()
+            for m in models_resp.data or []:
+                mid: str = m.id
+                if any(skip in mid for skip in _SKIP_MODEL_KINDS):
+                    continue
+                vision = _model_supports_vision(mid, m)
+                display: str = getattr(m, "display_name", None) or mid
+                result.append(ModelInfo(
+                    model_id=mid,
+                    display_name=display,
+                    provider=ProviderType.MISTRAL,
+                    supports_vision=vision,
+                    input_token_limit=None,
+                    output_token_limit=None,
+                ))
+            if result:
+                logger.info(
+                    "Mistral models fetched from API",
+                    extra={"count": len(result)},
+                )
+                return result
+        except Exception as exc:
+            logger.warning(
+                "Mistral API list_models échoué : %s — fallback liste statique", exc
+            )
+
         logger.info(
-            "Mistral models listed (static)",
-            extra={"provider": self.provider_type, "count": len(_MISTRAL_VISION_MODELS)},
+            "Mistral models : liste statique (fallback)",
+            extra={"count": len(_MISTRAL_FALLBACK_MODELS)},
         )
-        return list(_MISTRAL_VISION_MODELS)
+        return list(_MISTRAL_FALLBACK_MODELS)
 
     def generate_content(self, image_bytes: bytes, prompt: str, model_id: str) -> str:
-        if not self.is_configured():
-            raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
+        """Envoie image + prompt à Mistral et retourne le texte brut.
 
-        try:
-            from mistralai import Mistral  # v1.x — import local
-        except ImportError:
-            # Détecter si c'est mistralai v0.x (ne supporte pas la vision / Pixtral)
-            try:
-                import mistralai as _ms_pkg  # noqa: F401
-                _v0_present = True
-            except ImportError:
-                _v0_present = False
-            if _v0_present:
-                raise RuntimeError(
-                    "Le package mistralai est installé en version 0.x qui ne supporte pas "
-                    "la vision (Pixtral). Reconstruisez le container Docker pour obtenir "
-                    "mistralai>=1.0 : `docker build --no-cache ...`"
-                )
+        Bifurcation selon le support vision du modèle :
+          - Vision (Pixtral) : content multimodal avec image base64 + texte.
+          - Texte seul (Mistral Large, Small, Codestral…) : prompt texte uniquement,
+            l'image n'est pas transmise (avertissement loggé).
+        """
+        if not self.is_configured():
             raise RuntimeError(
-                "Le package mistralai n'est pas installé. "
-                "Ajoutez 'mistralai>=1.0' aux dépendances et reconstruisez le container."
+                f"Provider Mistral non disponible : vérifiez {_ENV_KEY} "
+                "et que mistralai>=1.0 est installé."
             )
 
-        api_key = os.environ[_ENV_KEY]
-        client = Mistral(api_key=api_key)
-
-        image_b64 = base64.b64encode(image_bytes).decode("utf-8")
-        data_url = f"data:image/jpeg;base64,{image_b64}"
+        from mistralai import Mistral
+
+        client = Mistral(api_key=os.environ[_ENV_KEY])
+
+        if _model_supports_vision(model_id):
+            image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+            data_url = f"data:image/jpeg;base64,{image_b64}"
+            content: object = [
+                {"type": "image_url", "image_url": {"url": data_url}},
+                {"type": "text", "text": prompt},
+            ]
+        else:
+            logger.warning(
+                "Modèle texte seul sélectionné pour une analyse image : %s. "
+                "L'image ne sera pas transmise à l'API.",
+                model_id,
+            )
+            content = prompt
 
         response = client.chat.complete(
             model=model_id,
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "image_url", "image_url": {"url": data_url}},
-                        {"type": "text", "text": prompt},
-                    ],
-                }
-            ],
+            messages=[{"role": "user", "content": content}],
         )
         choices = response.choices or []
         if not choices:

backend/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scriptorium-ai-backend"
-version = "0.1.0"
+version = "0.2.0"
 description = "Backend Scriptorium AI — plateforme générique d'éditions savantes augmentées"
 requires-python = ">=3.11"
 dependencies = [

backend/tests/test_provider_mistral.py

@@ -2,20 +2,117 @@
 Tests du provider Mistral AI (MistralProvider).
 
 Stratégie :
-  - Pas d'appel réseau réel : les appels SDK sont mockés via monkeypatch.
-  - is_configured() vérifié via variables d'env simulées.
-  - list_models() : vérification de la liste statique.
-  - generate_content() : mock du client Mistral.
+  - Pas d'appel réseau réel : SDK mocké via sys.modules.
+  - is_configured() : vérifié via variables d'env ET import mock.
+  - list_models() : mock de client.models.list() → comportement dynamique
+    et fallback statique quand l'API échoue.
+  - generate_content() : bifurcation vision / texte seul.
 """
 # 1. stdlib
-import os
+import sys
+import types as _types
 
 # 2. third-party
 import pytest
 
 # 3. local
 from app.schemas.model_config import ProviderType
-from app.services.ai.provider_mistral import MistralProvider, _MISTRAL_VISION_MODELS
+from app.services.ai.provider_mistral import (
+    MistralProvider,
+    _MISTRAL_FALLBACK_MODELS,
+    _MISTRAL_VISION_MODELS,  # alias backward-compat
+    _model_supports_vision,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers — faux SDK Mistral
+# ---------------------------------------------------------------------------
+
+class _FakeCaps:
+    """Capabilities d'un modèle Mistral (SDK v1.x)."""
+    def __init__(self, vision: bool = False):
+        self.vision = vision
+
+
+class _FakeModel:
+    def __init__(self, id_: str, vision: bool = False, display_name: str | None = None):
+        self.id = id_
+        self.display_name = display_name or id_
+        self.capabilities = _FakeCaps(vision=vision)
+
+
+class _FakeModelsListResponse:
+    def __init__(self, models: list[_FakeModel]):
+        self.data = models
+
+
+class _FakeModelsAPI:
+    def __init__(self, models: list[_FakeModel]):
+        self._models = models
+
+    def list(self) -> _FakeModelsListResponse:
+        return _FakeModelsListResponse(self._models)
+
+
+class _FakeMessage:
+    content = "Voici le JSON de la page."
+
+
+class _FakeChoice:
+    message = _FakeMessage()
+
+
+class _FakeChatResponse:
+    choices = [_FakeChoice()]
+
+
+class _FakeChat:
+    def complete(self, *, model, messages):
+        return _FakeChatResponse()
+
+
+def _make_fake_mistralai(models: list[_FakeModel] | None = None) -> _types.ModuleType:
+    """Crée un faux module mistralai avec Mistral class et modèles mockés."""
+    fake = _types.ModuleType("mistralai")
+    chat = _FakeChat()
+    models_api = _FakeModelsAPI(models or [])
+
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.chat = chat
+            self.models = models_api
+
+    fake.Mistral = _FakeMistral
+    return fake
+
+
+# ---------------------------------------------------------------------------
+# _model_supports_vision() — helper pur
+# ---------------------------------------------------------------------------
+
+def test_vision_detection_pixtral_by_name():
+    assert _model_supports_vision("pixtral-large-latest") is True
+    assert _model_supports_vision("pixtral-12b-2409") is True
+
+
+def test_vision_detection_text_models_by_name():
+    assert _model_supports_vision("mistral-large-latest") is False
+    assert _model_supports_vision("mistral-small-latest") is False
+    assert _model_supports_vision("codestral-latest") is False
+
+
+def test_vision_detection_uses_capabilities_when_available():
+    m_vision = _FakeModel("some-model", vision=True)
+    m_text = _FakeModel("some-model", vision=False)
+    assert _model_supports_vision("some-model", m_vision) is True
+    assert _model_supports_vision("some-model", m_text) is False
+
+
+def test_vision_detection_capabilities_override_name():
+    """capabilities.vision=False surpasse un nom contenant 'pixtral'."""
+    m = _FakeModel("pixtral-test", vision=False)
+    assert _model_supports_vision("pixtral-test", m) is False
 
 
 # ---------------------------------------------------------------------------
@@ -23,17 +120,42 @@ from app.services.ai.provider_mistral import MistralProvider, _MISTRAL_VISION_MO
 # ---------------------------------------------------------------------------
 
 def test_is_configured_true(monkeypatch):
+    """Clé présente + mistralai v1.x importable → True."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key-abc")
+    fake = _make_fake_mistralai()
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
     assert MistralProvider().is_configured() is True
 
 
-def test_is_configured_false(monkeypatch):
+def test_is_configured_false_no_key(monkeypatch):
+    """Pas de clé → False, même si mistralai est installé."""
     monkeypatch.delenv("MISTRAL_API_KEY", raising=False)
+    fake = _make_fake_mistralai()
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
     assert MistralProvider().is_configured() is False
 
 
-def test_is_configured_empty_key(monkeypatch):
+def test_is_configured_false_empty_key(monkeypatch):
     monkeypatch.setenv("MISTRAL_API_KEY", "")
+    fake = _make_fake_mistralai()
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+    assert MistralProvider().is_configured() is False
+
+
+def test_is_configured_false_v0x_installed(monkeypatch):
+    """Clé présente mais mistralai v0.x (pas de classe Mistral) → False."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    fake_v0 = _types.ModuleType("mistralai")
+    # Pas d'attribut Mistral → from mistralai import Mistral lèvera ImportError
+    monkeypatch.setitem(sys.modules, "mistralai", fake_v0)
+    assert MistralProvider().is_configured() is False
+
+
+def test_is_configured_false_mistralai_not_installed(monkeypatch):
+    """Clé présente mais mistralai pas du tout installé → False."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    # Supprimer mistralai du chemin d'import
+    monkeypatch.setitem(sys.modules, "mistralai", None)  # type: ignore[arg-type]
     assert MistralProvider().is_configured() is False
 
 
@@ -41,38 +163,85 @@ def test_is_configured_empty_key(monkeypatch):
 # provider_type
 # ---------------------------------------------------------------------------
 
-def test_provider_type():
+def test_provider_type(monkeypatch):
+    fake = _make_fake_mistralai()
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
     assert MistralProvider().provider_type == ProviderType.MISTRAL
 
 
 # ---------------------------------------------------------------------------
-# list_models()
+# list_models() — comportement dynamique
 # ---------------------------------------------------------------------------
 
-def test_list_models_returns_two(monkeypatch):
-    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
-    models = MistralProvider().list_models()
-    assert len(models) == 2
-
-
-def test_list_models_ids(monkeypatch):
+def _setup_list_models(monkeypatch, models: list[_FakeModel]) -> None:
+    """Configure le monkeypatch pour list_models()."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    fake = _make_fake_mistralai(models)
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
+
+def test_list_models_dynamic_returns_all_non_embed(monkeypatch):
+    """list_models() retourne tous les modèles sauf embeddings/modération."""
+    _setup_list_models(monkeypatch, [
+        _FakeModel("pixtral-large-latest", vision=True),
+        _FakeModel("pixtral-12b-2409", vision=True),
+        _FakeModel("mistral-large-latest", vision=False),
+        _FakeModel("mistral-embed", vision=False),       # exclut
+        _FakeModel("mistral-moderation", vision=False),  # exclut
+    ])
     models = MistralProvider().list_models()
     ids = {m.model_id for m in models}
     assert "pixtral-large-latest" in ids
     assert "pixtral-12b-2409" in ids
+    assert "mistral-large-latest" in ids
+    assert "mistral-embed" not in ids
+    assert "mistral-moderation" not in ids
+    assert len(models) == 3
+
+
+def test_list_models_vision_flag_from_capabilities(monkeypatch):
+    """supports_vision reflète capabilities.vision du SDK."""
+    _setup_list_models(monkeypatch, [
+        _FakeModel("pixtral-large-latest", vision=True),
+        _FakeModel("mistral-large-latest", vision=False),
+    ])
+    models = MistralProvider().list_models()
+    by_id = {m.model_id: m for m in models}
+    assert by_id["pixtral-large-latest"].supports_vision is True
+    assert by_id["mistral-large-latest"].supports_vision is False
 
 
-def test_list_models_all_vision(monkeypatch):
-    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+def test_list_models_all_mistral_provider(monkeypatch):
+    _setup_list_models(monkeypatch, [
+        _FakeModel("pixtral-large-latest", vision=True),
+        _FakeModel("mistral-large-latest", vision=False),
+    ])
     models = MistralProvider().list_models()
-    assert all(m.supports_vision for m in models)
+    assert all(m.provider == ProviderType.MISTRAL for m in models)
 
 
-def test_list_models_all_mistral_provider(monkeypatch):
+def test_list_models_fallback_when_api_fails(monkeypatch):
+    """Si client.models.list() lève une exception, retourne la liste statique."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    fake = _types.ModuleType("mistralai")
+
+    class _FailingModels:
+        def list(self):
+            raise RuntimeError("API timeout")
+
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.models = _FailingModels()
+
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
     models = MistralProvider().list_models()
-    assert all(m.provider == ProviderType.MISTRAL for m in models)
+    # Fallback = _MISTRAL_FALLBACK_MODELS = 2 modèles Pixtral
+    assert len(models) == 2
+    ids = {m.model_id for m in models}
+    assert "pixtral-large-latest" in ids
+    assert "pixtral-12b-2409" in ids
 
 
 def test_list_models_raises_if_not_configured(monkeypatch):
@@ -81,58 +250,91 @@ def test_list_models_raises_if_not_configured(monkeypatch):
         MistralProvider().list_models()
 
 
-def test_list_models_display_names(monkeypatch):
-    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
-    models = MistralProvider().list_models()
-    display_names = {m.display_name for m in models}
-    assert "Pixtral Large" in display_names
-    assert "Pixtral 12B" in display_names
+def test_list_models_fallback_backward_compat():
+    """_MISTRAL_VISION_MODELS est un alias de _MISTRAL_FALLBACK_MODELS."""
+    assert _MISTRAL_VISION_MODELS is _MISTRAL_FALLBACK_MODELS
 
 
 # ---------------------------------------------------------------------------
-# generate_content() — SDK mocké
+# generate_content() — bifurcation vision / texte
 # ---------------------------------------------------------------------------
 
-class _MockMessage:
-    content = "Voici le JSON de la page."
+def test_generate_content_vision_model_returns_text(monkeypatch):
+    """Modèle vision (Pixtral) : envoie l'image et retourne la réponse."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    fake = _make_fake_mistralai()
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
+    result = MistralProvider().generate_content(
+        b"fake-jpeg", "Analyse ce folio.", "pixtral-large-latest"
+    )
+    assert result == "Voici le JSON de la page."
+
 
+def test_generate_content_text_model_returns_text(monkeypatch):
+    """Modèle texte (Mistral Large) : envoie seulement le prompt, retourne la réponse."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    fake = _make_fake_mistralai()
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
+    result = MistralProvider().generate_content(
+        b"fake-jpeg", "Analyse ce folio.", "mistral-large-latest"
+    )
+    assert result == "Voici le JSON de la page."
 
-class _MockChoice:
-    message = _MockMessage()
 
+def test_generate_content_vision_sends_image_url(monkeypatch):
+    """Modèle vision : le message content contient image_url + text."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    captured: list[dict] = []
 
-class _MockResponse:
-    choices = [_MockChoice()]
+    class _CapturingChat:
+        def complete(self, *, model, messages):
+            captured.extend(messages)
+            return _FakeChatResponse()
 
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.chat = _CapturingChat()
+            self.models = _FakeModelsAPI([])
 
-class _MockChat:
-    def complete(self, *, model, messages):
-        return _MockResponse()
+    fake = _types.ModuleType("mistralai")
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
 
+    MistralProvider().generate_content(b"jpeg", "prompt", "pixtral-large-latest")
 
-class _MockMistralClient:
-    chat = _MockChat()
+    assert len(captured) == 1
+    content = captured[0]["content"]
+    assert isinstance(content, list)
+    types_sent = {item["type"] for item in content}
+    assert "image_url" in types_sent
+    assert "text" in types_sent
 
 
-def test_generate_content_returns_text(monkeypatch):
+def test_generate_content_text_sends_string_content(monkeypatch):
+    """Modèle texte : le message content est une chaîne (pas d'image)."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    captured: list[dict] = []
 
-    def _mock_mistral_cls(api_key):  # noqa: ARG001
-        return _MockMistralClient()
+    class _CapturingChat:
+        def complete(self, *, model, messages):
+            captured.extend(messages)
+            return _FakeChatResponse()
 
-    import app.services.ai.provider_mistral as mod
-    monkeypatch.setattr(mod, "MistralProvider", MistralProvider)
-    # On patch l'import interne dans generate_content()
-    import sys
-    import types as _types
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.chat = _CapturingChat()
+            self.models = _FakeModelsAPI([])
 
-    fake_mistralai = _types.ModuleType("mistralai")
-    fake_mistralai.Mistral = _mock_mistral_cls
-    monkeypatch.setitem(sys.modules, "mistralai", fake_mistralai)
+    fake = _types.ModuleType("mistralai")
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
 
-    provider = MistralProvider()
-    result = provider.generate_content(b"fake-jpeg", "Analyse ce folio.", "pixtral-large-latest")
-    assert result == "Voici le JSON de la page."
+    MistralProvider().generate_content(b"jpeg", "mon prompt", "mistral-large-latest")
+
+    assert len(captured) == 1
+    assert captured[0]["content"] == "mon prompt"
 
 
 def test_generate_content_raises_if_not_configured(monkeypatch):
@@ -141,42 +343,34 @@ def test_generate_content_raises_if_not_configured(monkeypatch):
         MistralProvider().generate_content(b"img", "prompt", "pixtral-large-latest")
 
 
-def test_generate_content_empty_response(monkeypatch):
-    """Si choices est vide, retourne une chaîne vide sans lever d'exception."""
+def test_generate_content_raises_if_v0x_installed(monkeypatch):
+    """Si mistralai v0.x est installé (is_configured() → False), RuntimeError clair."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    fake_v0 = _types.ModuleType("mistralai")
+    monkeypatch.setitem(sys.modules, "mistralai", fake_v0)
+
+    with pytest.raises(RuntimeError, match="mistralai>=1.0"):
+        MistralProvider().generate_content(b"img", "prompt", "pixtral-large-latest")
 
-    class _EmptyResp:
-        choices = []
+
+def test_generate_content_empty_response(monkeypatch):
+    """Si choices est vide, retourne une chaîne vide sans exception."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
 
     class _EmptyChat:
         def complete(self, *, model, messages):
+            class _EmptyResp:
+                choices = []
             return _EmptyResp()
 
-    class _EmptyClient:
-        chat = _EmptyChat()
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.chat = _EmptyChat()
+            self.models = _FakeModelsAPI([])
 
-    import sys
-    import types as _types
-
-    fake_mistralai = _types.ModuleType("mistralai")
-    fake_mistralai.Mistral = lambda api_key: _EmptyClient()
-    monkeypatch.setitem(sys.modules, "mistralai", fake_mistralai)
+    fake = _types.ModuleType("mistralai")
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
 
     result = MistralProvider().generate_content(b"img", "prompt", "pixtral-large-latest")
     assert result == ""
-
-
-def test_generate_content_v0_package_raises_runtime_error(monkeypatch):
-    """Si mistralai est installé en v0.x (pas de classe Mistral), lève RuntimeError avec un message clair."""
-    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
-
-    import sys
-    import types as _types
-
-    # Simuler mistralai v0.x : le module existe mais n'a pas la classe Mistral
-    fake_mistralai_v0 = _types.ModuleType("mistralai")
-    # Pas d'attribut Mistral → from mistralai import Mistral lèvera ImportError
-    monkeypatch.setitem(sys.modules, "mistralai", fake_mistralai_v0)
-
-    with pytest.raises(RuntimeError, match="version 0.x"):
-        MistralProvider().generate_content(b"img", "prompt", "pixtral-large-latest")

infra/Dockerfile

@@ -38,6 +38,11 @@ RUN mkdir -p /tmp/build/app \
     && pip install --no-cache-dir --upgrade /tmp/build/ \
     && rm -rf /tmp/build
 
+# ── Layer dédié mistralai — invalide le cache HF si v0.x est présent ─────
+# Layer séparé de l'install principal pour forcer la mise à jour même si
+# HuggingFace réutilise le layer pyproject.toml depuis un build antérieur.
+RUN pip install --no-cache-dir 'mistralai>=1.0,<2.0'
+
 # ── Code source backend ────────────────────────────────────────────────────
 COPY backend/app ./backend/app
 COPY profiles/ ./profiles/