fix(vertex): corriger le routing API pour VERTEX_API_KEY — ajouter vertexai=True

Cause racine du 403 PERMISSION_DENIED dans les logs de production :
genai.Client(api_key=VERTEX_API_KEY)
→ route vers generativelanguage.googleapis.com (Gemini Developer API)
→ rejette les clés Vertex Express avec 403 car elles ne sont pas
autorisées sur cette API

Fix :
genai.Client(vertexai=True, api_key=VERTEX_API_KEY)
→ route vers aiplatform.googleapis.com (Vertex AI endpoint correct)
→ project/location omis car mutually exclusive avec api_key dans le
constructeur SDK (la clé Express encode le projet)

Confirmé par le code source du SDK google-genai 1.67.0 :
"api_key: Applies to the Gemini Developer API only"
"project/location and API key are mutually exclusive"

Fichiers modifiés :
- provider_vertex_key.py : _build_client() avec vertexai=True,
fallback modèles Vertex sans supported_generation_methods (nom "gemini")
- client_factory.py : même correction pour cohérence
- test_ai_providers.py : 3 nouveaux tests Vertex (vertexai flag,
modèles sans méthodes, generate_content), assertion mise à jour
- test_ai_analyzer.py : assertion MockClient mise à jour

https://claude.ai/code/session_018woyEHc8HG2th7V4ewJ4Kg

backend/app/services/ai/client_factory.py

@@ -57,8 +57,12 @@ def build_client(provider_type: ProviderType) -> genai.Client:
             raise RuntimeError(
                 "Variable d'environnement manquante : VERTEX_API_KEY"
             )
-        logger.debug("Client Vertex AI (clé API) créé")
-        return genai.Client(api_key=api_key)
+        logger.debug("Client Vertex AI Express (clé API) créé")
+        # vertexai=True route vers aiplatform.googleapis.com (Vertex AI).
+        # Sans vertexai=True, le SDK route vers generativelanguage.googleapis.com
+        # (Gemini Developer API) qui rejette les clés Vertex Express avec 403.
+        # project/location sont omis : mutually exclusive avec api_key dans le SDK.
+        return genai.Client(vertexai=True, api_key=api_key)
 
     if provider_type == ProviderType.VERTEX_SERVICE_ACCOUNT:
         sa_json_str = os.environ.get("VERTEX_SERVICE_ACCOUNT_JSON")

backend/app/services/ai/provider_vertex_key.py

@@ -1,5 +1,14 @@
 """
-Provider Vertex AI — authentification via clé API GCP (VERTEX_API_KEY).
+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)
 """
 # 1. stdlib
 import logging
@@ -19,10 +28,12 @@ _ENV_KEY = "VERTEX_API_KEY"
 
 
 class VertexAPIKeyProvider(AIProvider):
-    """Provider Vertex AI via clé API GCP (VERTEX_API_KEY).
+    """Provider Vertex AI via clé API Express (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.
+    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.
     """
 
     @property
@@ -32,16 +43,36 @@ class VertexAPIKeyProvider(AIProvider):
     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],
+        )
+
     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])
+        client = self._build_client()
         result: list[ModelInfo] = []
 
         for model in client.models.list():
             methods = getattr(model, "supported_generation_methods", []) or []
-            if "generateContent" not in methods:
+            # 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(
@@ -54,15 +85,15 @@ class VertexAPIKeyProvider(AIProvider):
             ))
 
         logger.info(
-            "Vertex API key models fetched",
-            extra={"provider": self.provider_type, "count": len(result)},
+            "Vertex API key (Express) models fetched",
+            extra={"provider": self.provider_type.value, "count": len(result)},
         )
         return result
 
     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 = genai.Client(api_key=os.environ[_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,

backend/tests/test_ai_analyzer.py

@@ -198,7 +198,7 @@ def test_build_client_vertex_api_key(monkeypatch):
         mock_cls.return_value = MagicMock()
         client = build_client(ProviderType.VERTEX_API_KEY)
 
-    mock_cls.assert_called_once_with(api_key="fake-vertex-key")
+    mock_cls.assert_called_once_with(vertexai=True, api_key="fake-vertex-key")
     assert client is mock_cls.return_value
 
 

backend/tests/test_ai_providers.py

@@ -261,7 +261,46 @@ def test_vertex_key_provider_list_models_success(monkeypatch):
     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")
+    # 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."""
+    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()
+
+
+def test_vertex_key_provider_generate_content_uses_vertexai(monkeypatch):
+    """generate_content doit aussi utiliser vertexai=True."""
+    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"
 
 
 # ---------------------------------------------------------------------------