fix(providers): désactiver vertex_api_key + ajouter OCR Mistral dédié

─── vertex_api_key : désactivé (is_configured() → toujours False) ───────────
Cause confirmée par les logs production :
- Sans vertexai=True → 403 sur generativelanguage.googleapis.com
- Avec vertexai=True → 401 UNAUTHENTICATED sur aiplatform.googleapis.com
"API keys are not supported by this API. Expected OAuth2 access token."

aiplatform.googleapis.com n'accepte pas les clés API, uniquement OAuth2.
Le provider reste déclaré mais is_configured() retourne False immédiatement
avec un message expliquant les alternatives (GOOGLE_AI_STUDIO_API_KEY ou
VERTEX_SERVICE_ACCOUNT_JSON). Plus d'appels réseau voués à l'échec.

─── Mistral OCR : endpoint dédié client.ocr.process() ───────────────────────
Le SDK Mistral v1.x expose client.ocr.process() (OCRResponse.pages[].markdown)
qui est fondamentalement différent de client.chat.complete() :
- Endpoint dédié, pas de chat completions
- Retourne du markdown structuré page par page (pas un message)
- Document = ImageURLChunk (base64 data URI)

generate_content() bifurque maintenant sur 3 chemins :
1. "ocr" dans l'ID → client.ocr.process(), pages concaténées en markdown
2. Vision (Pixtral) → client.chat.complete() multimodal image_url+text
3. Texte seul → client.chat.complete() prompt texte uniquement

mistral-ocr-latest ajouté dans la liste statique de fallback et injecté dans
list_models() si absent de la liste dynamique (endpoint séparé de models.list).

Tests : +6 tests OCR, tests vertex_api_key mis à jour (provider indisponible),
assertions list_all_models refactorisées pour utiliser SA provider à la place.

https://claude.ai/code/session_018woyEHc8HG2th7V4ewJ4Kg

backend/app/services/ai/provider_mistral.py

@@ -2,18 +2,19 @@
 Provider Mistral — authentification via MISTRAL_API_KEY.
 
 Découverte dynamique des modèles via client.models.list() (SDK v1.x).
-Fallback statique sur Pixtral Large + 12B si l'API est inaccessible.
+Fallback statique sur Pixtral Large + 12B + mistral-ocr-latest 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.
+Si seule la version 0.x est installée, le provider est marqué indisponible.
+
+Trois types d'appel selon le modèle sélectionné :
+  1. OCR (mistral-ocr-latest, "ocr" dans l'ID) :
+       client.ocr.process() → retourne du markdown structuré par page.
+       Endpoint dédié, différent de chat completions.
+  2. Vision (Pixtral, capabilities.vision=True, "pixtral" ou "vision" dans l'ID) :
+       client.chat.complete() avec content multimodal (image base64 + texte).
+  3. Texte seul (Mistral Large, Small, Codestral…) :
+       client.chat.complete() avec content texte uniquement (image non transmise).
 """
 # 1. stdlib
 import base64
@@ -31,6 +32,9 @@ _ENV_KEY = "MISTRAL_API_KEY"
 # Sous-chaînes d'IDs de modèles non génératifs à exclure de la liste
 _SKIP_MODEL_KINDS = ("embed", "moderation")
 
+# Modèle OCR dédié — endpoint client.ocr.process(), pas chat completions
+_OCR_MODEL_ID = "mistral-ocr-latest"
+
 # Liste statique de secours — utilisée si client.models.list() échoue
 _MISTRAL_FALLBACK_MODELS: list[ModelInfo] = [
     ModelInfo(
@@ -49,24 +53,37 @@ _MISTRAL_FALLBACK_MODELS: list[ModelInfo] = [
         input_token_limit=128_000,
         output_token_limit=None,
     ),
+    ModelInfo(
+        model_id=_OCR_MODEL_ID,
+        display_name="Mistral OCR",
+        provider=ProviderType.MISTRAL,
+        supports_vision=True,
+        input_token_limit=None,
+        output_token_limit=None,
+    ),
 ]
 
 # Alias backward-compat (utilisé dans certains tests)
 _MISTRAL_VISION_MODELS = _MISTRAL_FALLBACK_MODELS
 
 
+def _is_ocr_model(model_id: str) -> bool:
+    """Retourne True si le modèle utilise l'endpoint OCR dédié (pas chat completions)."""
+    return "ocr" in model_id.lower()
+
+
 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.
+    sinon se rabat sur la présence de 'pixtral', 'vision' ou 'ocr' 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
+    return "pixtral" in mid or "vision" in mid or "ocr" in mid
 
 
 class MistralProvider(AIProvider):
@@ -102,8 +119,8 @@ class MistralProvider(AIProvider):
 
         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.
+        Ajoute mistral-ocr-latest s'il n'est pas déjà dans la liste (endpoint dédié).
+        Fallback sur la liste statique si l'API est inaccessible.
         """
         if not self.is_configured():
             raise RuntimeError(
@@ -132,12 +149,26 @@ class MistralProvider(AIProvider):
                     input_token_limit=None,
                     output_token_limit=None,
                 ))
+
             if result:
+                # Ajouter mistral-ocr-latest s'il n'est pas dans la liste dynamique
+                # (endpoint OCR dédié, pas toujours dans models.list())
+                ids_in_result = {m.model_id for m in result}
+                if _OCR_MODEL_ID not in ids_in_result:
+                    result.append(ModelInfo(
+                        model_id=_OCR_MODEL_ID,
+                        display_name="Mistral OCR",
+                        provider=ProviderType.MISTRAL,
+                        supports_vision=True,
+                        input_token_limit=None,
+                        output_token_limit=None,
+                    ))
                 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
@@ -152,10 +183,15 @@ class MistralProvider(AIProvider):
     def generate_content(self, image_bytes: bytes, prompt: str, model_id: str) -> str:
         """Envoie image + prompt à Mistral et retourne le texte brut.
 
-        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é).
+        Trois chemins selon le modèle :
+          1. OCR (mistral-ocr-latest) :
+               client.ocr.process() → markdown de toutes les pages concaténées.
+               L'endpoint OCR retourne du texte structuré, pas des messages chat.
+          2. Vision (Pixtral) :
+               client.chat.complete() avec content multimodal (image base64 + texte).
+          3. Texte seul (Mistral Large, Small, Codestral) :
+               client.chat.complete() avec prompt texte uniquement.
+               L'image n'est pas transmise (avertissement loggé).
         """
         if not self.is_configured():
             raise RuntimeError(
@@ -166,14 +202,29 @@ class MistralProvider(AIProvider):
         from mistralai import Mistral
 
         client = Mistral(api_key=os.environ[_ENV_KEY])
+        image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+        data_url = f"data:image/jpeg;base64,{image_b64}"
+
+        # ── Chemin 1 : OCR dédié ─────────────────────────────────────────────
+        if _is_ocr_model(model_id):
+            logger.info("Mistral OCR : endpoint dédié client.ocr.process()", extra={"model": model_id})
+            response = client.ocr.process(
+                model=model_id,
+                document={"type": "image_url", "image_url": {"url": data_url}},
+            )
+            # OCRResponse.pages : list[OCRPageObject], chacun avec .markdown
+            pages = getattr(response, "pages", []) or []
+            return "\n\n".join(
+                getattr(page, "markdown", "") for page in pages
+            )
 
+        # ── Chemin 2 : Vision multimodale (Pixtral) ──────────────────────────
         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},
             ]
+        # ── Chemin 3 : Texte seul ─────────────────────────────────────────────
         else:
             logger.warning(
                 "Modèle texte seul sélectionné pour une analyse image : %s. "

backend/app/services/ai/provider_vertex_key.py

@@ -1,39 +1,51 @@
 """
 Provider Vertex AI — authentification via clé API Express Vertex (VERTEX_API_KEY).
 
-La clé Vertex Express (format AQ.Ab...) encode le projet GCP ; elle est utilisée
-avec vertexai=True pour router vers aiplatform.googleapis.com (et non vers
-generativelanguage.googleapis.com qui est l'endpoint Google AI Studio).
-
-Référence SDK google-genai :
-  api_key seul               → Gemini Developer API (generativelanguage)
-  vertexai=True + api_key    → Vertex AI Express mode (aiplatform)
-  project/location + api_key → ValueError (mutually exclusive dans le constructeur)
+ÉTAT : NON FONCTIONNEL — aiplatform.googleapis.com n'accepte pas les clés API.
+
+Diagnostic :
+  - Sans vertexai=True → generativelanguage.googleapis.com → 403 (clé Vertex rejetée)
+  - Avec vertexai=True  → aiplatform.googleapis.com → 401 UNAUTHENTICATED
+    "API keys are not supported by this API. Expected OAuth2 access token."
+
+Cause : Vertex AI (aiplatform) n'accepte que OAuth2 / service account / ADC.
+Les clés API (format AQ.Ab...) ne sont pas prises en charge par cette API.
+
+Alternatives fonctionnelles :
+  1. Google AI Studio : GOOGLE_AI_STUDIO_API_KEY (clé AIza...) → fonctionne
+  2. Vertex AI Service Account : VERTEX_SERVICE_ACCOUNT_JSON → fonctionne
+
+Ce provider est conservé pour la cohérence de l'interface mais is_configured()
+retourne toujours False afin d'éviter des appels réseau voués à l'échec.
 """
 # 1. stdlib
 import logging
 import os
 
 # 2. third-party
-from google import genai
-from google.genai import types
+from google.genai import types  # noqa: F401  (conservé pour import cohérence)
 
 # 3. local
 from app.schemas.model_config import ModelInfo, ProviderType
-from app.services.ai.base import AIProvider, is_vision_model
+from app.services.ai.base import AIProvider
 
 logger = logging.getLogger(__name__)
 
 _ENV_KEY = "VERTEX_API_KEY"
 
+_UNAVAILABLE_MSG = (
+    "VERTEX_API_KEY définie mais aiplatform.googleapis.com n'accepte pas les "
+    "clés API (OAuth2 requis). Utilisez GOOGLE_AI_STUDIO_API_KEY pour le "
+    "Gemini Developer API, ou VERTEX_SERVICE_ACCOUNT_JSON pour Vertex AI."
+)
+
 
 class VertexAPIKeyProvider(AIProvider):
-    """Provider Vertex AI via clé API Express (VERTEX_API_KEY).
+    """Provider Vertex AI via clé API Express — NON FONCTIONNEL.
 
-    Utilise genai.Client(vertexai=True, api_key=...) pour router vers
-    l'endpoint Vertex AI (aiplatform.googleapis.com). La clé Express encode
-    le projet GCP ; project/location explicites sont omis car ils sont
-    mutually exclusive avec api_key dans le constructeur SDK.
+    aiplatform.googleapis.com exige OAuth2/service account ; les clés API
+    sont systématiquement rejetées avec 401 UNAUTHENTICATED.
+    Ce provider reste présent mais is_configured() retourne toujours False.
     """
 
     @property
@@ -41,62 +53,12 @@ class VertexAPIKeyProvider(AIProvider):
         return ProviderType.VERTEX_API_KEY
 
     def is_configured(self) -> bool:
-        return bool(os.environ.get(_ENV_KEY))
-
-    def _build_client(self) -> genai.Client:
-        """Construit un client Vertex AI en mode Express API key.
-
-        vertexai=True route vers aiplatform.googleapis.com.
-        project/location sont omis : mutually exclusive avec api_key
-        dans le SDK (la clé Express encode le projet).
-        """
-        return genai.Client(
-            vertexai=True,
-            api_key=os.environ[_ENV_KEY],
-        )
+        if os.environ.get(_ENV_KEY):
+            logger.warning(_UNAVAILABLE_MSG)
+        return False
 
     def list_models(self) -> list[ModelInfo]:
-        if not self.is_configured():
-            raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
-
-        client = self._build_client()
-        result: list[ModelInfo] = []
-
-        for model in client.models.list():
-            methods = getattr(model, "supported_generation_methods", []) or []
-            # Pour Vertex, certains modèles peuvent ne pas avoir
-            # supported_generation_methods renseigné ; on les inclut
-            # s'ils contiennent "gemini" dans le nom (modèles génératifs Vertex).
-            name_lower = (getattr(model, "name", "") or "").lower()
-            is_generative = (
-                "generateContent" in methods
-                or (not methods and "gemini" in name_lower)
-            )
-            if not is_generative:
-                continue
-
-            result.append(ModelInfo(
-                model_id=model.name,
-                display_name=getattr(model, "display_name", model.name),
-                provider=self.provider_type,
-                supports_vision=is_vision_model(model),
-                input_token_limit=getattr(model, "input_token_limit", None),
-                output_token_limit=getattr(model, "output_token_limit", None),
-            ))
-
-        logger.info(
-            "Vertex API key (Express) models fetched",
-            extra={"provider": self.provider_type.value, "count": len(result)},
-        )
-        return result
+        raise RuntimeError(_UNAVAILABLE_MSG)
 
     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}")
-        client = self._build_client()
-        image_part = types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg")
-        response = client.models.generate_content(
-            model=model_id,
-            contents=[image_part, prompt],
-        )
-        return response.text or ""
+        raise RuntimeError(_UNAVAILABLE_MSG)

backend/tests/test_ai_providers.py

@@ -232,75 +232,27 @@ def test_vertex_key_provider_not_configured(monkeypatch):
     assert VertexAPIKeyProvider().is_configured() is False
 
 
-def test_vertex_key_provider_configured(monkeypatch):
+def test_vertex_key_provider_always_unavailable_even_with_key(monkeypatch):
+    """aiplatform.googleapis.com rejette les clés API → is_configured() toujours False."""
     monkeypatch.setenv("VERTEX_API_KEY", "fake-vertex-key")
-    assert VertexAPIKeyProvider().is_configured() is True
+    assert VertexAPIKeyProvider().is_configured() is False
 
 
 def test_vertex_key_provider_type():
     assert VertexAPIKeyProvider().provider_type == ProviderType.VERTEX_API_KEY
 
 
-def test_vertex_key_provider_list_models_not_configured(monkeypatch):
-    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
-    with pytest.raises(RuntimeError, match="VERTEX_API_KEY"):
-        VertexAPIKeyProvider().list_models()
-
-
-def test_vertex_key_provider_list_models_success(monkeypatch):
-    monkeypatch.setenv("VERTEX_API_KEY", "fake-vertex-key")
-    mock_model = _make_mock_model(
-        name="models/gemini-2.0-flash",
-        display_name="Gemini 2.0 Flash",
-    )
-
-    with patch("app.services.ai.provider_vertex_key.genai.Client") as MockClient:
-        MockClient.return_value.models.list.return_value = [mock_model]
-        models = VertexAPIKeyProvider().list_models()
-
-    assert len(models) == 1
-    assert models[0].model_id == "models/gemini-2.0-flash"
-    assert models[0].provider == ProviderType.VERTEX_API_KEY
-    # vertexai=True est obligatoire pour router vers aiplatform.googleapis.com
-    # (sans ça, le SDK route vers generativelanguage.googleapis.com → 403)
-    MockClient.assert_called_once_with(vertexai=True, api_key="fake-vertex-key")
-
-
-def test_vertex_key_provider_list_models_includes_gemini_without_methods(monkeypatch):
-    """Vertex peut retourner des modèles sans supported_generation_methods.
-    Si le nom contient 'gemini', on les inclut quand même."""
+def test_vertex_key_provider_list_models_raises(monkeypatch):
+    """list_models() et generate_content() lèvent RuntimeError (provider indisponible)."""
     monkeypatch.setenv("VERTEX_API_KEY", "fake-vertex-key")
-    model_no_methods = _make_mock_model(
-        name="publishers/google/models/gemini-1.5-pro-002",
-        display_name="Gemini 1.5 Pro 002",
-        methods=[],
-    )
-    model_non_gemini = _make_mock_model(
-        name="publishers/google/models/text-bison",
-        display_name="Text Bison",
-        methods=[],
-    )
-
-    with patch("app.services.ai.provider_vertex_key.genai.Client") as MockClient:
-        MockClient.return_value.models.list.return_value = [model_no_methods, model_non_gemini]
-        models = VertexAPIKeyProvider().list_models()
-
-    assert len(models) == 1
-    assert "gemini" in models[0].model_id.lower()
+    with pytest.raises(RuntimeError, match="aiplatform"):
+        VertexAPIKeyProvider().list_models()
 
 
-def test_vertex_key_provider_generate_content_uses_vertexai(monkeypatch):
-    """generate_content doit aussi utiliser vertexai=True."""
+def test_vertex_key_provider_generate_content_raises(monkeypatch):
     monkeypatch.setenv("VERTEX_API_KEY", "fake-vertex-key")
-
-    with patch("app.services.ai.provider_vertex_key.genai.Client") as MockClient:
-        with patch("app.services.ai.provider_vertex_key.types.Part.from_bytes") as mock_part:
-            mock_part.return_value = "fake-part"
-            MockClient.return_value.models.generate_content.return_value.text = "result"
-            result = VertexAPIKeyProvider().generate_content(b"img", "prompt", "gemini-2.0-flash")
-
-    MockClient.assert_called_once_with(vertexai=True, api_key="fake-vertex-key")
-    assert result == "result"
+    with pytest.raises(RuntimeError, match="aiplatform"):
+        VertexAPIKeyProvider().generate_content(b"img", "prompt", "gemini-2.0-flash")
 
 
 # ---------------------------------------------------------------------------
@@ -417,12 +369,13 @@ def test_list_all_models_one_provider(monkeypatch):
 
 
 def test_list_all_models_aggregates_multiple_providers(monkeypatch):
-    # Note : provider_google_ai et provider_vertex_key partagent le même objet
-    # google.genai (import module). On patch au niveau des méthodes pour éviter
-    # que le second patch.object("...genai.Client") écrase le premier.
+    """Deux providers configurés → les deux listes sont agrégées.
+    VertexAPIKeyProvider est toujours indisponible (aiplatform n'accepte pas les clés).
+    On utilise Google AI Studio + Vertex Service Account pour tester l'agrégation.
+    """
     monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key-ai")
-    monkeypatch.setenv("VERTEX_API_KEY", "fake-key-vertex")
-    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
+    monkeypatch.setenv("VERTEX_SERVICE_ACCOUNT_JSON", "{}")  # déclenche is_configured()
 
     models_ai = [ModelInfo(
         model_id="models/gemini-1.5-pro",
@@ -430,41 +383,42 @@ def test_list_all_models_aggregates_multiple_providers(monkeypatch):
         provider=ProviderType.GOOGLE_AI_STUDIO,
         supports_vision=True,
     )]
-    models_vertex = [ModelInfo(
+    models_sa = [ModelInfo(
         model_id="models/gemini-2.0-flash",
         display_name="Gemini 2.0 Flash",
-        provider=ProviderType.VERTEX_API_KEY,
+        provider=ProviderType.VERTEX_SERVICE_ACCOUNT,
         supports_vision=True,
     )]
 
     with patch.object(GoogleAIProvider, "list_models", return_value=models_ai):
-        with patch.object(VertexAPIKeyProvider, "list_models", return_value=models_vertex):
+        with patch.object(VertexServiceAccountProvider, "list_models", return_value=models_sa):
             result = list_all_models()
 
     assert len(result) == 2
     providers = {m.provider for m in result}
     assert ProviderType.GOOGLE_AI_STUDIO in providers
-    assert ProviderType.VERTEX_API_KEY in providers
+    assert ProviderType.VERTEX_SERVICE_ACCOUNT in providers
 
 
 def test_list_all_models_failing_provider_is_skipped(monkeypatch):
+    """Un provider configuré qui échoue est ignoré ; l'autre est retourné."""
     monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "bad-key")
-    monkeypatch.setenv("VERTEX_API_KEY", "good-key")
-    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    monkeypatch.setenv("VERTEX_SERVICE_ACCOUNT_JSON", "{}")
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
 
-    models_vertex = [ModelInfo(
+    models_sa = [ModelInfo(
         model_id="models/gemini-2.0-flash",
         display_name="Gemini 2.0 Flash",
-        provider=ProviderType.VERTEX_API_KEY,
+        provider=ProviderType.VERTEX_SERVICE_ACCOUNT,
         supports_vision=True,
     )]
 
     with patch.object(GoogleAIProvider, "list_models", side_effect=Exception("API key invalid")):
-        with patch.object(VertexAPIKeyProvider, "list_models", return_value=models_vertex):
+        with patch.object(VertexServiceAccountProvider, "list_models", return_value=models_sa):
             result = list_all_models()
 
     assert len(result) == 1
-    assert result[0].provider == ProviderType.VERTEX_API_KEY
+    assert result[0].provider == ProviderType.VERTEX_SERVICE_ACCOUNT
 
 
 # ---------------------------------------------------------------------------

backend/tests/test_provider_mistral.py

@@ -181,7 +181,8 @@ def _setup_list_models(monkeypatch, models: list[_FakeModel]) -> None:
 
 
 def test_list_models_dynamic_returns_all_non_embed(monkeypatch):
-    """list_models() retourne tous les modèles sauf embeddings/modération."""
+    """list_models() retourne tous les modèles sauf embeddings/modération.
+    mistral-ocr-latest est toujours ajouté s'il n'est pas dans la liste dynamique."""
     _setup_list_models(monkeypatch, [
         _FakeModel("pixtral-large-latest", vision=True),
         _FakeModel("pixtral-12b-2409", vision=True),
@@ -194,9 +195,10 @@ def test_list_models_dynamic_returns_all_non_embed(monkeypatch):
     assert "pixtral-large-latest" in ids
     assert "pixtral-12b-2409" in ids
     assert "mistral-large-latest" in ids
+    assert "mistral-ocr-latest" in ids   # ajouté automatiquement
     assert "mistral-embed" not in ids
     assert "mistral-moderation" not in ids
-    assert len(models) == 3
+    assert len(models) == 4  # 3 filtres + OCR ajouté
 
 
 def test_list_models_vision_flag_from_capabilities(monkeypatch):
@@ -237,11 +239,12 @@ def test_list_models_fallback_when_api_fails(monkeypatch):
     monkeypatch.setitem(sys.modules, "mistralai", fake)
 
     models = MistralProvider().list_models()
-    # Fallback = _MISTRAL_FALLBACK_MODELS = 2 modèles Pixtral
-    assert len(models) == 2
+    # Fallback = _MISTRAL_FALLBACK_MODELS = Pixtral Large + 12B + mistral-ocr-latest
+    assert len(models) == 3
     ids = {m.model_id for m in models}
     assert "pixtral-large-latest" in ids
     assert "pixtral-12b-2409" in ids
+    assert "mistral-ocr-latest" in ids
 
 
 def test_list_models_raises_if_not_configured(monkeypatch):
@@ -374,3 +377,132 @@ def test_generate_content_empty_response(monkeypatch):
 
     result = MistralProvider().generate_content(b"img", "prompt", "pixtral-large-latest")
     assert result == ""
+
+
+# ---------------------------------------------------------------------------
+# generate_content() — chemin OCR dédié (mistral-ocr-latest)
+# ---------------------------------------------------------------------------
+
+def test_generate_content_ocr_uses_ocr_endpoint(monkeypatch):
+    """mistral-ocr-latest utilise client.ocr.process(), pas client.chat.complete()."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+
+    ocr_calls: list[dict] = []
+    chat_calls: list = []
+
+    class _FakeOCRPage:
+        markdown = "Explicit liber primus..."
+
+    class _FakeOCRResponse:
+        pages = [_FakeOCRPage(), _FakeOCRPage()]
+
+    class _FakeOCR:
+        def process(self, *, model, document):
+            ocr_calls.append({"model": model, "document": document})
+            return _FakeOCRResponse()
+
+    class _FakeChat:
+        def complete(self, *, model, messages):
+            chat_calls.append(messages)
+
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.ocr = _FakeOCR()
+            self.chat = _FakeChat()
+            self.models = _FakeModelsAPI([])
+
+    fake = _types.ModuleType("mistralai")
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
+    result = MistralProvider().generate_content(b"jpeg", "prompt", "mistral-ocr-latest")
+
+    # OCR endpoint appelé, pas chat
+    assert len(ocr_calls) == 1
+    assert len(chat_calls) == 0
+    assert ocr_calls[0]["model"] == "mistral-ocr-latest"
+    # Document doit être image_url avec data URI
+    doc = ocr_calls[0]["document"]
+    assert doc["type"] == "image_url"
+    assert doc["image_url"]["url"].startswith("data:image/jpeg;base64,")
+    # Résultat = pages concaténées
+    assert "Explicit liber primus..." in result
+
+
+def test_generate_content_ocr_concatenates_pages(monkeypatch):
+    """OCR multi-pages : les markdowns sont concaténés par double saut de ligne."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+
+    class _Page:
+        def __init__(self, md):
+            self.markdown = md
+
+    class _FakeOCRResponse:
+        pages = [_Page("Page 1 texte"), _Page("Page 2 texte")]
+
+    class _FakeOCR:
+        def process(self, **kwargs):
+            return _FakeOCRResponse()
+
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.ocr = _FakeOCR()
+            self.models = _FakeModelsAPI([])
+
+    fake = _types.ModuleType("mistralai")
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
+    result = MistralProvider().generate_content(b"jpeg", "prompt", "mistral-ocr-latest")
+
+    assert "Page 1 texte" in result
+    assert "Page 2 texte" in result
+    assert "\n\n" in result
+
+
+def test_generate_content_ocr_model_not_called_for_vision(monkeypatch):
+    """Un modèle Pixtral NE passe PAS par l'endpoint OCR."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    ocr_called = []
+
+    class _FakeOCR:
+        def process(self, **kwargs):
+            ocr_called.append(True)
+
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.ocr = _FakeOCR()
+            self.chat = type("C", (), {"complete": lambda self, **k: _FakeChatResponse()})()
+            self.models = _FakeModelsAPI([])
+
+    fake = _types.ModuleType("mistralai")
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
+    MistralProvider().generate_content(b"jpeg", "prompt", "pixtral-large-latest")
+    assert len(ocr_called) == 0
+
+
+def test_generate_content_ocr_model_detected_by_id(monkeypatch):
+    """Tout modèle contenant 'ocr' dans l'ID utilise l'endpoint OCR."""
+    monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
+    ocr_called = []
+
+    class _FakeOCR:
+        def process(self, **kwargs):
+            ocr_called.append(True)
+            class R:
+                pages = []
+            return R()
+
+    class _FakeMistral:
+        def __init__(self, api_key):
+            self.ocr = _FakeOCR()
+            self.models = _FakeModelsAPI([])
+
+    fake = _types.ModuleType("mistralai")
+    fake.Mistral = _FakeMistral
+    monkeypatch.setitem(sys.modules, "mistralai", fake)
+
+    MistralProvider().generate_content(b"jpeg", "prompt", "mistral-ocr-latest")
+    assert len(ocr_called) == 1