src/providers/vertexai/provider.rs (1)

490-515: Response parsing will fail for Gemini API (API key mode) due to format mismatch.

The code at lines 498-515 expects Vertex AI :predict response format with predictions[].embeddings.values, but the Gemini API :embedContent endpoint (used in API key mode) returns {"embedding": {"values": [...]}} without a predictions array. The .ok_or(StatusCode::INTERNAL_SERVER_ERROR)? call will fail when parsing API key mode responses.

src/providers/vertexai/provider.rs (2)

493-518: Response parsing assumes Vertex AI format, but API key mode uses Gemini API with a different response structure.

When uses_api_key() is true, requests go to the Gemini embedContent endpoint, which returns:

{"embedding": {"values": [...]}}

However, the response parsing at lines 500-518 expects Vertex AI format:

{"predictions": [{"embeddings": {"values": [...]}}]}

This will cause INTERNAL_SERVER_ERROR at line 503 for all API key mode embedding requests since predictions field won't exist.

Proposed fix: Handle both response formats

             // Normal processing for regular API responses
             let gemini_response: serde_json::Value =
                 serde_json::from_str(&response_text).map_err(|e| {
                     error!("Failed to parse response as JSON: {}", e);
                     StatusCode::INTERNAL_SERVER_ERROR
                 })?;

-            // Extract embeddings from updated response format
-            let embeddings = gemini_response["predictions"]
-                .as_array()
-                .ok_or(StatusCode::INTERNAL_SERVER_ERROR)?
-                .iter()
-                .enumerate()
-                .map(|(i, pred)| Embeddings {
-                    object: "embedding".to_string(),
-                    embedding: Embedding::Float(
-                        pred["embeddings"]["values"]
-                            .as_array()
-                            .unwrap_or(&vec![])
-                            .iter()
-                            .filter_map(|v| v.as_f64().map(|f| f as f32))
-                            .collect::<Vec<f32>>(),
-                    ),
-                    index: i,
-                })
-                .collect();
+            // Handle different response formats based on auth mode
+            let embeddings = if self.uses_api_key() {
+                // Gemini embedContent format: {"embedding": {"values": [...]}}
+                let values = gemini_response["embedding"]["values"]
+                    .as_array()
+                    .ok_or_else(|| {
+                        error!("Missing embedding.values in Gemini response");
+                        StatusCode::INTERNAL_SERVER_ERROR
+                    })?;
+                vec![Embeddings {
+                    object: "embedding".to_string(),
+                    embedding: Embedding::Float(
+                        values
+                            .iter()
+                            .filter_map(|v| v.as_f64().map(|f| f as f32))
+                            .collect::<Vec<f32>>(),
+                    ),
+                    index: 0,
+                }]
+            } else {
+                // Vertex AI format: {"predictions": [{"embeddings": {"values": [...]}}]}
+                gemini_response["predictions"]
+                    .as_array()
+                    .ok_or(StatusCode::INTERNAL_SERVER_ERROR)?
+                    .iter()
+                    .enumerate()
+                    .map(|(i, pred)| Embeddings {
+                        object: "embedding".to_string(),
+                        embedding: Embedding::Float(
+                            pred["embeddings"]["values"]
+                                .as_array()
+                                .unwrap_or(&vec![])
+                                .iter()
+                                .filter_map(|v| v.as_f64().map(|f| f as f32))
+                                .collect::<Vec<f32>>(),
+                        ),
+                        index: i,
+                    })
+                    .collect()
+            };

---

537-561: Test helper doesn't handle API key mode where location can be empty.

The with_test_client method unconditionally calls validate_location at line 552, but in API key mode, location_str can be empty. This will cause the test helper to panic with "Invalid location provided" when testing API key authentication.

Consider aligning with the new() constructor logic:

Proposed fix

         let location_str = config
             .params
             .get("location")
             .cloned()
             .unwrap_or_else(|| "".to_string());

-        let location = Self::validate_location(&location_str)
-            .expect("Invalid location provided for test client configuration");
+        let location = if location_str.is_empty() {
+            String::new()
+        } else {
+            Self::validate_location(&location_str)
+                .expect("Invalid location provided for test client configuration")
+        };

tests/provider_api_tests.rs (1)

815-825: Formatting issue detected by CI — run cargo fmt.

The pipeline failure indicates formatting issues around these assertion lines. Please run cargo fmt to fix the code style.

🔧 Suggested fix

     // Verify the configuration was stored and retrieved correctly
     if let ProviderConfig::VertexAI(config) = provider_response.config {
-        assert_eq!(config.project_id, Some("test-project-transform".to_string()));
-        assert_eq!(config.location, Some("us-central1".to_string()));
+        assert_eq!(
+            config.project_id,
+            Some("test-project-transform".to_string())
+        );
+        assert_eq!(config.location, Some("us-central1".to_string()));
         assert_eq!(
             config.credentials_path,
             Some("/path/to/credentials.json".to_string())
         );