Sprint 2 Session A — Couche providers Google AI (3 modes d'auth)

Schéma :
- model_config.py : ProviderType, ModelInfo (frozen), ModelConfig

Service AI :
- base.py : ABC AIProvider + helper is_vision_model
- provider_google_ai.py : Mode 1 — GOOGLE_AI_STUDIO_API_KEY (google-genai SDK)
- provider_vertex_key.py : Mode 2 — VERTEX_API_KEY (google-genai SDK)
- provider_vertex_sa.py : Mode 3 — VERTEX_SERVICE_ACCOUNT_JSON (google-auth SA)
- model_registry.py : list_all_models() + build_model_config() agrégés

Règles respectées :
- R06 : clés API uniquement via os.environ
- R08 : 37 tests pytest, 91/91 passés
- R11 : import exclusivement `from google import genai`
- Providers non configurés ignorés silencieusement
- Providers défaillants loggés en warning, non propagés

Deps : google-genai>=1.0, google-auth>=2.0 (httpx déjà présent)

https://claude.ai/code/session_018woyEHc8HG2th7V4ewJ4Kg

backend/app/schemas/model_config.py

@@ -0,0 +1,41 @@
+"""
+Schémas Pydantic pour la configuration et la découverte des modèles IA.
+"""
+# 1. stdlib
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+# 2. third-party
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ProviderType(str, Enum):
+    GOOGLE_AI_STUDIO = "google_ai_studio"
+    VERTEX_API_KEY = "vertex_api_key"
+    VERTEX_SERVICE_ACCOUNT = "vertex_service_account"
+
+
+class ModelInfo(BaseModel):
+    """Décrit un modèle IA disponible chez un provider."""
+
+    model_config = ConfigDict(frozen=True)
+
+    model_id: str
+    display_name: str
+    provider: ProviderType
+    supports_vision: bool
+    input_token_limit: int | None = None
+    output_token_limit: int | None = None
+
+
+class ModelConfig(BaseModel):
+    """Configuration du modèle sélectionné pour un corpus (CLAUDE.md §9)."""
+
+    corpus_id: str
+    selected_model_id: str
+    selected_model_display_name: str
+    provider: ProviderType
+    supports_vision: bool
+    last_fetched_at: datetime
+    available_models: list[dict[str, Any]]  # cache sérialisé des ModelInfo

backend/app/services/ai/__init__.py

@@ -0,0 +1,15 @@
+"""
+Services AI — providers Google AI et registre de modèles.
+"""
+from app.services.ai.model_registry import build_model_config, list_all_models
+from app.services.ai.provider_google_ai import GoogleAIProvider
+from app.services.ai.provider_vertex_key import VertexAPIKeyProvider
+from app.services.ai.provider_vertex_sa import VertexServiceAccountProvider
+
+__all__ = [
+    "GoogleAIProvider",
+    "VertexAPIKeyProvider",
+    "VertexServiceAccountProvider",
+    "list_all_models",
+    "build_model_config",
+]

backend/app/services/ai/base.py

@@ -0,0 +1,42 @@
+"""
+Interface abstraite commune à tous les providers Google AI.
+"""
+# 1. stdlib
+from abc import ABC, abstractmethod
+from typing import Any
+
+# 2. local
+from app.schemas.model_config import ModelInfo, ProviderType
+
+
+def is_vision_model(model: Any) -> bool:
+    """Détermine si un modèle supporte les entrées image.
+
+    Les modèles Gemini sont tous multimodaux ; les modèles texte-only (ex :
+    embedding, AQA) ne contiennent pas 'gemini' dans leur identifiant.
+    """
+    name = (getattr(model, "name", "") or "").lower()
+    display = (getattr(model, "display_name", "") or "").lower()
+    return "gemini" in name or "vision" in name or "vision" in display
+
+
+class AIProvider(ABC):
+    """Interface commune à tous les providers Google AI."""
+
+    @property
+    @abstractmethod
+    def provider_type(self) -> ProviderType: ...
+
+    @abstractmethod
+    def is_configured(self) -> bool:
+        """Retourne True si les credentials nécessaires sont présents en environnement."""
+        ...
+
+    @abstractmethod
+    def list_models(self) -> list[ModelInfo]:
+        """Liste les modèles filtrés (generateContent présent dans les méthodes supportées).
+
+        Lève RuntimeError si le provider n'est pas configuré.
+        Propage les exceptions réseau/API sans les masquer.
+        """
+        ...

backend/app/services/ai/model_registry.py

@@ -0,0 +1,82 @@
+"""
+Registre agrégé des modèles disponibles tous providers confondus.
+"""
+# 1. stdlib
+import logging
+from datetime import datetime, timezone
+
+# 2. local
+from app.schemas.model_config import ModelConfig, ModelInfo
+from app.services.ai.base import AIProvider
+from app.services.ai.provider_google_ai import GoogleAIProvider
+from app.services.ai.provider_vertex_key import VertexAPIKeyProvider
+from app.services.ai.provider_vertex_sa import VertexServiceAccountProvider
+
+logger = logging.getLogger(__name__)
+
+
+def _build_providers() -> list[AIProvider]:
+    return [
+        GoogleAIProvider(),
+        VertexAPIKeyProvider(),
+        VertexServiceAccountProvider(),
+    ]
+
+
+def list_all_models() -> list[ModelInfo]:
+    """Interroge tous les providers configurés et retourne la liste agrégée.
+
+    - Un provider non configuré (credentials absentes) est silencieusement ignoré.
+    - Un provider défaillant (clé invalide, erreur réseau) logue un warning et est ignoré.
+    """
+    result: list[ModelInfo] = []
+
+    for provider in _build_providers():
+        if not provider.is_configured():
+            logger.debug(
+                "Provider non configuré, ignoré",
+                extra={"provider": provider.provider_type},
+            )
+            continue
+
+        try:
+            models = provider.list_models()
+            result.extend(models)
+            logger.info(
+                "Provider interrogé avec succès",
+                extra={"provider": provider.provider_type, "count": len(models)},
+            )
+        except Exception as exc:
+            logger.warning(
+                "Provider inaccessible",
+                extra={"provider": provider.provider_type, "error": str(exc)},
+            )
+
+    return result
+
+
+def build_model_config(corpus_id: str, selected_model_id: str) -> ModelConfig:
+    """Construit un ModelConfig à partir d'un model_id sélectionné.
+
+    Lève ValueError si le modèle n'est pas dans la liste des disponibles.
+    """
+    models = list_all_models()
+    model_map = {m.model_id: m for m in models}
+
+    if selected_model_id not in model_map:
+        available = sorted(model_map.keys())
+        raise ValueError(
+            f"Modèle '{selected_model_id}' non disponible. "
+            f"Modèles disponibles : {available}"
+        )
+
+    selected = model_map[selected_model_id]
+    return ModelConfig(
+        corpus_id=corpus_id,
+        selected_model_id=selected.model_id,
+        selected_model_display_name=selected.display_name,
+        provider=selected.provider,
+        supports_vision=selected.supports_vision,
+        last_fetched_at=datetime.now(tz=timezone.utc),
+        available_models=[m.model_dump() for m in models],
+    )

backend/app/services/ai/provider_google_ai.py

@@ -0,0 +1,55 @@
+"""
+Provider Google AI Studio — authentification via GOOGLE_AI_STUDIO_API_KEY.
+"""
+# 1. stdlib
+import logging
+import os
+
+# 2. third-party
+from google import genai
+
+# 3. local
+from app.schemas.model_config import ModelInfo, ProviderType
+from app.services.ai.base import AIProvider, is_vision_model
+
+logger = logging.getLogger(__name__)
+
+_ENV_KEY = "GOOGLE_AI_STUDIO_API_KEY"
+
+
+class GoogleAIProvider(AIProvider):
+    """Provider Google AI Studio (clé API GOOGLE_AI_STUDIO_API_KEY)."""
+
+    @property
+    def provider_type(self) -> ProviderType:
+        return ProviderType.GOOGLE_AI_STUDIO
+
+    def is_configured(self) -> bool:
+        return bool(os.environ.get(_ENV_KEY))
+
+    def list_models(self) -> list[ModelInfo]:
+        if not self.is_configured():
+            raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
+
+        client = genai.Client(api_key=os.environ[_ENV_KEY])
+        result: list[ModelInfo] = []
+
+        for model in client.models.list():
+            methods = getattr(model, "supported_generation_methods", []) or []
+            if "generateContent" not in methods:
+                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(
+            "Google AI Studio models fetched",
+            extra={"provider": self.provider_type, "count": len(result)},
+        )
+        return result

backend/app/services/ai/provider_vertex_key.py

@@ -0,0 +1,59 @@
+"""
+Provider Vertex AI — authentification via clé API GCP (VERTEX_API_KEY).
+"""
+# 1. stdlib
+import logging
+import os
+
+# 2. third-party
+from google import genai
+
+# 3. local
+from app.schemas.model_config import ModelInfo, ProviderType
+from app.services.ai.base import AIProvider, is_vision_model
+
+logger = logging.getLogger(__name__)
+
+_ENV_KEY = "VERTEX_API_KEY"
+
+
+class VertexAPIKeyProvider(AIProvider):
+    """Provider Vertex AI via clé API GCP (VERTEX_API_KEY).
+
+    Utilise le SDK google-genai avec la clé GCP. La clé doit être autorisée
+    sur l'API Generative Language dans la console GCP.
+    """
+
+    @property
+    def provider_type(self) -> ProviderType:
+        return ProviderType.VERTEX_API_KEY
+
+    def is_configured(self) -> bool:
+        return bool(os.environ.get(_ENV_KEY))
+
+    def list_models(self) -> list[ModelInfo]:
+        if not self.is_configured():
+            raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
+
+        client = genai.Client(api_key=os.environ[_ENV_KEY])
+        result: list[ModelInfo] = []
+
+        for model in client.models.list():
+            methods = getattr(model, "supported_generation_methods", []) or []
+            if "generateContent" not in methods:
+                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 models fetched",
+            extra={"provider": self.provider_type, "count": len(result)},
+        )
+        return result

backend/app/services/ai/provider_vertex_sa.py

@@ -0,0 +1,90 @@
+"""
+Provider Vertex AI — authentification via compte de service JSON (VERTEX_SERVICE_ACCOUNT_JSON).
+"""
+# 1. stdlib
+import json
+import logging
+import os
+
+# 2. third-party
+from google import genai
+from google.oauth2 import service_account
+
+# 3. local
+from app.schemas.model_config import ModelInfo, ProviderType
+from app.services.ai.base import AIProvider, is_vision_model
+
+logger = logging.getLogger(__name__)
+
+_ENV_KEY = "VERTEX_SERVICE_ACCOUNT_JSON"
+_VERTEX_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"]
+_DEFAULT_LOCATION = "us-central1"
+
+
+class VertexServiceAccountProvider(AIProvider):
+    """Provider Vertex AI via compte de service JSON (VERTEX_SERVICE_ACCOUNT_JSON).
+
+    Le JSON complet du compte de service est lu depuis la variable d'environnement.
+    Le project_id est extrait du JSON ; la localisation par défaut est us-central1.
+    """
+
+    @property
+    def provider_type(self) -> ProviderType:
+        return ProviderType.VERTEX_SERVICE_ACCOUNT
+
+    def is_configured(self) -> bool:
+        return bool(os.environ.get(_ENV_KEY))
+
+    def list_models(self) -> list[ModelInfo]:
+        if not self.is_configured():
+            raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
+
+        sa_json_str = os.environ[_ENV_KEY]
+        try:
+            sa_info = json.loads(sa_json_str)
+        except json.JSONDecodeError as exc:
+            raise ValueError(
+                f"{_ENV_KEY} : JSON invalide — {exc}"
+            ) from exc
+
+        project_id: str | None = sa_info.get("project_id")
+        if not project_id:
+            raise ValueError(
+                f"{_ENV_KEY} : champ 'project_id' manquant dans le JSON"
+            )
+
+        credentials = service_account.Credentials.from_service_account_info(
+            sa_info,
+            scopes=_VERTEX_SCOPES,
+        )
+        client = genai.Client(
+            vertexai=True,
+            project=project_id,
+            location=_DEFAULT_LOCATION,
+            credentials=credentials,
+        )
+        result: list[ModelInfo] = []
+
+        for model in client.models.list():
+            methods = getattr(model, "supported_generation_methods", []) or []
+            if "generateContent" not in methods:
+                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 service account models fetched",
+            extra={
+                "provider": self.provider_type,
+                "project": project_id,
+                "count": len(result),
+            },
+        )
+        return result

backend/pyproject.toml

@@ -13,7 +13,9 @@ dependencies = [
     "pydantic>=2.7",
     "sqlalchemy>=2.0",
     "aiosqlite>=0.20",
-    "google-generativeai>=0.3",
+    "google-genai>=1.0",
+    "google-auth>=2.0",
+    "httpx>=0.27",
     "lxml>=5.2",
     "Pillow>=10.3",
 ]

backend/tests/test_ai_providers.py

@@ -0,0 +1,471 @@
+"""
+Tests des providers Google AI et du registre de modèles.
+Aucun appel réseau réel — tous les clients SDK sont mockés.
+"""
+# 1. stdlib
+import json
+from datetime import datetime, timezone
+from unittest.mock import MagicMock, patch
+
+# 2. third-party
+import pytest
+from pydantic import ValidationError
+
+# 3. local
+from app.schemas.model_config import ModelConfig, ModelInfo, ProviderType
+from app.services.ai.base import is_vision_model
+from app.services.ai.model_registry import build_model_config, list_all_models
+from app.services.ai.provider_google_ai import GoogleAIProvider
+from app.services.ai.provider_vertex_key import VertexAPIKeyProvider
+from app.services.ai.provider_vertex_sa import VertexServiceAccountProvider
+
+# ---------------------------------------------------------------------------
+# Données de test partagées
+# ---------------------------------------------------------------------------
+
+FAKE_SA_JSON = {
+    "type": "service_account",
+    "project_id": "test-project-123",
+    "private_key_id": "key-abc",
+    "private_key": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEA\n-----END RSA PRIVATE KEY-----\n",
+    "client_email": "test-sa@test-project-123.iam.gserviceaccount.com",
+    "client_id": "123456789",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+}
+
+
+def _make_mock_model(
+    name: str = "models/gemini-1.5-pro",
+    display_name: str = "Gemini 1.5 Pro",
+    methods: list[str] | None = None,
+    input_token_limit: int = 1_000_000,
+    output_token_limit: int = 8192,
+) -> MagicMock:
+    """Construit un objet modèle factice imitant google.genai.types.Model."""
+    m = MagicMock()
+    m.name = name
+    m.display_name = display_name
+    m.supported_generation_methods = methods if methods is not None else ["generateContent"]
+    m.input_token_limit = input_token_limit
+    m.output_token_limit = output_token_limit
+    return m
+
+
+# ---------------------------------------------------------------------------
+# Tests — ModelInfo (schéma)
+# ---------------------------------------------------------------------------
+
+def test_model_info_valid():
+    info = ModelInfo(
+        model_id="models/gemini-1.5-pro",
+        display_name="Gemini 1.5 Pro",
+        provider=ProviderType.GOOGLE_AI_STUDIO,
+        supports_vision=True,
+        input_token_limit=1_000_000,
+        output_token_limit=8192,
+    )
+    assert info.model_id == "models/gemini-1.5-pro"
+    assert info.supports_vision is True
+
+
+def test_model_info_is_frozen():
+    info = ModelInfo(
+        model_id="models/gemini-1.5-pro",
+        display_name="Gemini 1.5 Pro",
+        provider=ProviderType.GOOGLE_AI_STUDIO,
+        supports_vision=True,
+    )
+    with pytest.raises((TypeError, ValidationError)):
+        info.model_id = "changed"  # type: ignore[misc]
+
+
+def test_model_info_optional_token_limits():
+    info = ModelInfo(
+        model_id="models/gemini-2.0-flash",
+        display_name="Gemini 2.0 Flash",
+        provider=ProviderType.VERTEX_SERVICE_ACCOUNT,
+        supports_vision=True,
+    )
+    assert info.input_token_limit is None
+    assert info.output_token_limit is None
+
+
+def test_model_info_all_provider_types():
+    for ptype in ProviderType:
+        info = ModelInfo(
+            model_id=f"models/test-{ptype.value}",
+            display_name="Test",
+            provider=ptype,
+            supports_vision=False,
+        )
+        assert info.provider == ptype
+
+
+# ---------------------------------------------------------------------------
+# Tests — ModelConfig (schéma)
+# ---------------------------------------------------------------------------
+
+def test_model_config_valid():
+    cfg = ModelConfig(
+        corpus_id="corpus-001",
+        selected_model_id="models/gemini-1.5-pro",
+        selected_model_display_name="Gemini 1.5 Pro",
+        provider=ProviderType.GOOGLE_AI_STUDIO,
+        supports_vision=True,
+        last_fetched_at=datetime(2026, 3, 17, tzinfo=timezone.utc),
+        available_models=[],
+    )
+    assert cfg.corpus_id == "corpus-001"
+    assert cfg.supports_vision is True
+
+
+def test_model_config_missing_required_field():
+    with pytest.raises(ValidationError):
+        ModelConfig.model_validate({"corpus_id": "x"})
+
+
+# ---------------------------------------------------------------------------
+# Tests — is_vision_model helper
+# ---------------------------------------------------------------------------
+
+def test_is_vision_model_gemini():
+    m = MagicMock()
+    m.name = "models/gemini-1.5-pro"
+    m.display_name = "Gemini 1.5 Pro"
+    assert is_vision_model(m) is True
+
+
+def test_is_vision_model_vision_in_name():
+    m = MagicMock()
+    m.name = "models/some-vision-model"
+    m.display_name = "Some Model"
+    assert is_vision_model(m) is True
+
+
+def test_is_vision_model_vision_in_display():
+    m = MagicMock()
+    m.name = "models/some-model"
+    m.display_name = "Some Vision Model"
+    assert is_vision_model(m) is True
+
+
+def test_is_vision_model_text_only():
+    m = MagicMock()
+    m.name = "models/text-embedding-004"
+    m.display_name = "Text Embedding"
+    assert is_vision_model(m) is False
+
+
+# ---------------------------------------------------------------------------
+# Tests — GoogleAIProvider
+# ---------------------------------------------------------------------------
+
+def test_google_ai_provider_not_configured(monkeypatch):
+    monkeypatch.delenv("GOOGLE_AI_STUDIO_API_KEY", raising=False)
+    provider = GoogleAIProvider()
+    assert provider.is_configured() is False
+
+
+def test_google_ai_provider_configured(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key")
+    provider = GoogleAIProvider()
+    assert provider.is_configured() is True
+
+
+def test_google_ai_provider_type():
+    assert GoogleAIProvider().provider_type == ProviderType.GOOGLE_AI_STUDIO
+
+
+def test_google_ai_provider_list_models_not_configured(monkeypatch):
+    monkeypatch.delenv("GOOGLE_AI_STUDIO_API_KEY", raising=False)
+    with pytest.raises(RuntimeError, match="GOOGLE_AI_STUDIO_API_KEY"):
+        GoogleAIProvider().list_models()
+
+
+def test_google_ai_provider_list_models_success(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key")
+    mock_model = _make_mock_model()
+
+    with patch("app.services.ai.provider_google_ai.genai.Client") as MockClient:
+        MockClient.return_value.models.list.return_value = [mock_model]
+        models = GoogleAIProvider().list_models()
+
+    assert len(models) == 1
+    assert models[0].model_id == "models/gemini-1.5-pro"
+    assert models[0].provider == ProviderType.GOOGLE_AI_STUDIO
+    assert models[0].supports_vision is True
+    MockClient.assert_called_once_with(api_key="fake-key")
+
+
+def test_google_ai_provider_filters_non_generate_content(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key")
+    embedding = _make_mock_model(
+        name="models/text-embedding-004",
+        display_name="Text Embedding",
+        methods=["embedContent"],
+    )
+    gemini = _make_mock_model()
+
+    with patch("app.services.ai.provider_google_ai.genai.Client") as MockClient:
+        MockClient.return_value.models.list.return_value = [embedding, gemini]
+        models = GoogleAIProvider().list_models()
+
+    assert len(models) == 1
+    assert models[0].model_id == "models/gemini-1.5-pro"
+
+
+def test_google_ai_provider_empty_list(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key")
+    with patch("app.services.ai.provider_google_ai.genai.Client") as MockClient:
+        MockClient.return_value.models.list.return_value = []
+        models = GoogleAIProvider().list_models()
+    assert models == []
+
+
+# ---------------------------------------------------------------------------
+# Tests — VertexAPIKeyProvider
+# ---------------------------------------------------------------------------
+
+def test_vertex_key_provider_not_configured(monkeypatch):
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
+    assert VertexAPIKeyProvider().is_configured() is False
+
+
+def test_vertex_key_provider_configured(monkeypatch):
+    monkeypatch.setenv("VERTEX_API_KEY", "fake-vertex-key")
+    assert VertexAPIKeyProvider().is_configured() is True
+
+
+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
+    MockClient.assert_called_once_with(api_key="fake-vertex-key")
+
+
+# ---------------------------------------------------------------------------
+# Tests — VertexServiceAccountProvider
+# ---------------------------------------------------------------------------
+
+def test_vertex_sa_provider_not_configured(monkeypatch):
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    assert VertexServiceAccountProvider().is_configured() is False
+
+
+def test_vertex_sa_provider_configured(monkeypatch):
+    monkeypatch.setenv("VERTEX_SERVICE_ACCOUNT_JSON", json.dumps(FAKE_SA_JSON))
+    assert VertexServiceAccountProvider().is_configured() is True
+
+
+def test_vertex_sa_provider_type():
+    assert VertexServiceAccountProvider().provider_type == ProviderType.VERTEX_SERVICE_ACCOUNT
+
+
+def test_vertex_sa_provider_list_models_not_configured(monkeypatch):
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    with pytest.raises(RuntimeError, match="VERTEX_SERVICE_ACCOUNT_JSON"):
+        VertexServiceAccountProvider().list_models()
+
+
+def test_vertex_sa_provider_invalid_json(monkeypatch):
+    monkeypatch.setenv("VERTEX_SERVICE_ACCOUNT_JSON", "not-valid-json{{{")
+    with pytest.raises(ValueError, match="JSON invalide"):
+        VertexServiceAccountProvider().list_models()
+
+
+def test_vertex_sa_provider_missing_project_id(monkeypatch):
+    sa_no_project = {k: v for k, v in FAKE_SA_JSON.items() if k != "project_id"}
+    monkeypatch.setenv("VERTEX_SERVICE_ACCOUNT_JSON", json.dumps(sa_no_project))
+    with pytest.raises(ValueError, match="project_id"):
+        VertexServiceAccountProvider().list_models()
+
+
+def test_vertex_sa_provider_list_models_success(monkeypatch):
+    monkeypatch.setenv("VERTEX_SERVICE_ACCOUNT_JSON", json.dumps(FAKE_SA_JSON))
+    mock_model = _make_mock_model(
+        name="models/gemini-1.5-pro-002",
+        display_name="Gemini 1.5 Pro 002",
+    )
+    mock_credentials = MagicMock()
+
+    with patch(
+        "app.services.ai.provider_vertex_sa.service_account.Credentials.from_service_account_info",
+        return_value=mock_credentials,
+    ) as mock_creds_factory:
+        with patch("app.services.ai.provider_vertex_sa.genai.Client") as MockClient:
+            MockClient.return_value.models.list.return_value = [mock_model]
+            models = VertexServiceAccountProvider().list_models()
+
+    assert len(models) == 1
+    assert models[0].model_id == "models/gemini-1.5-pro-002"
+    assert models[0].provider == ProviderType.VERTEX_SERVICE_ACCOUNT
+    mock_creds_factory.assert_called_once_with(
+        FAKE_SA_JSON,
+        scopes=["https://www.googleapis.com/auth/cloud-platform"],
+    )
+    MockClient.assert_called_once_with(
+        vertexai=True,
+        project="test-project-123",
+        location="us-central1",
+        credentials=mock_credentials,
+    )
+
+
+def test_vertex_sa_provider_filters_non_generate_content(monkeypatch):
+    monkeypatch.setenv("VERTEX_SERVICE_ACCOUNT_JSON", json.dumps(FAKE_SA_JSON))
+    embedding = _make_mock_model(
+        name="models/textembedding-gecko",
+        display_name="Text Embedding Gecko",
+        methods=["embedContent"],
+    )
+
+    with patch(
+        "app.services.ai.provider_vertex_sa.service_account.Credentials.from_service_account_info",
+        return_value=MagicMock(),
+    ):
+        with patch("app.services.ai.provider_vertex_sa.genai.Client") as MockClient:
+            MockClient.return_value.models.list.return_value = [embedding]
+            models = VertexServiceAccountProvider().list_models()
+
+    assert models == []
+
+
+# ---------------------------------------------------------------------------
+# Tests — model_registry.list_all_models
+# ---------------------------------------------------------------------------
+
+def test_list_all_models_no_providers_configured(monkeypatch):
+    monkeypatch.delenv("GOOGLE_AI_STUDIO_API_KEY", raising=False)
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    result = list_all_models()
+    assert result == []
+
+
+def test_list_all_models_one_provider(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key")
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    mock_model = _make_mock_model()
+
+    with patch("app.services.ai.provider_google_ai.genai.Client") as MockClient:
+        MockClient.return_value.models.list.return_value = [mock_model]
+        result = list_all_models()
+
+    assert len(result) == 1
+    assert result[0].provider == ProviderType.GOOGLE_AI_STUDIO
+
+
+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.
+    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)
+
+    models_ai = [ModelInfo(
+        model_id="models/gemini-1.5-pro",
+        display_name="Gemini 1.5 Pro",
+        provider=ProviderType.GOOGLE_AI_STUDIO,
+        supports_vision=True,
+    )]
+    models_vertex = [ModelInfo(
+        model_id="models/gemini-2.0-flash",
+        display_name="Gemini 2.0 Flash",
+        provider=ProviderType.VERTEX_API_KEY,
+        supports_vision=True,
+    )]
+
+    with patch.object(GoogleAIProvider, "list_models", return_value=models_ai):
+        with patch.object(VertexAPIKeyProvider, "list_models", return_value=models_vertex):
+            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
+
+
+def test_list_all_models_failing_provider_is_skipped(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "bad-key")
+    monkeypatch.setenv("VERTEX_API_KEY", "good-key")
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+
+    models_vertex = [ModelInfo(
+        model_id="models/gemini-2.0-flash",
+        display_name="Gemini 2.0 Flash",
+        provider=ProviderType.VERTEX_API_KEY,
+        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):
+            result = list_all_models()
+
+    assert len(result) == 1
+    assert result[0].provider == ProviderType.VERTEX_API_KEY
+
+
+# ---------------------------------------------------------------------------
+# Tests — model_registry.build_model_config
+# ---------------------------------------------------------------------------
+
+def test_build_model_config_valid(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key")
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    mock_model = _make_mock_model()
+
+    with patch("app.services.ai.provider_google_ai.genai.Client") as MockClient:
+        MockClient.return_value.models.list.return_value = [mock_model]
+        cfg = build_model_config("corpus-001", "models/gemini-1.5-pro")
+
+    assert cfg.corpus_id == "corpus-001"
+    assert cfg.selected_model_id == "models/gemini-1.5-pro"
+    assert cfg.selected_model_display_name == "Gemini 1.5 Pro"
+    assert cfg.provider == ProviderType.GOOGLE_AI_STUDIO
+    assert cfg.supports_vision is True
+    assert len(cfg.available_models) == 1
+    assert isinstance(cfg.available_models[0], dict)
+
+
+def test_build_model_config_unknown_model(monkeypatch):
+    monkeypatch.setenv("GOOGLE_AI_STUDIO_API_KEY", "fake-key")
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    mock_model = _make_mock_model()
+
+    with patch("app.services.ai.provider_google_ai.genai.Client") as MockClient:
+        MockClient.return_value.models.list.return_value = [mock_model]
+        with pytest.raises(ValueError, match="non disponible"):
+            build_model_config("corpus-001", "models/nonexistent-model")
+
+
+def test_build_model_config_no_providers(monkeypatch):
+    monkeypatch.delenv("GOOGLE_AI_STUDIO_API_KEY", raising=False)
+    monkeypatch.delenv("VERTEX_API_KEY", raising=False)
+    monkeypatch.delenv("VERTEX_SERVICE_ACCOUNT_JSON", raising=False)
+    with pytest.raises(ValueError, match="non disponible"):
+        build_model_config("corpus-001", "models/gemini-1.5-pro")