Vector settings: don't assume which kind of request is asked when looking at a settings update without fragments

crates/milli/src/update/settings.rs

@@ -2131,9 +2131,19 @@ pub fn validate_embedding_settings(
         })?;
     }
 
-    // if we are working with partial settings, the user could have changed only the `request` and not given again the fragments
+    // used below
-    if context == EmbeddingValidationContext::FullSettings {
+    enum WithFragments {
-        if let Some(request) = request.as_ref().set() {
+        Yes {
+            indexing_fragments: BTreeMap<String, serde_json::Value>,
+            search_fragments: BTreeMap<String, serde_json::Value>,
+        },
+        No,
+        Maybe,
+    }
+
+    let with_fragments = {
+        let has_reset = matches!(indexing_fragments, Setting::Reset)
+            || matches!(search_fragments, Setting::Reset);
         let indexing_fragments: BTreeMap<_, _> = indexing_fragments
             .as_ref()
             .set()
@@ -2153,6 +2163,9 @@ pub fn validate_embedding_settings(
             })
             .collect();
 
+        let has_fragments = !indexing_fragments.is_empty() || !search_fragments.is_empty();
+
+        if context == EmbeddingValidationContext::FullSettings {
             let are_fragments_inconsistent =
                 indexing_fragments.is_empty() ^ search_fragments.is_empty();
             if are_fragments_inconsistent {
@@ -2163,19 +2176,66 @@ pub fn validate_embedding_settings(
                 ))
                 .map_err(|error| crate::UserError::VectorEmbeddingError(error.into()).into());
             }
-
+        }
-            let request = crate::vector::rest::RequestData::new(
+        if has_fragments {
+            if context == EmbeddingValidationContext::SettingsPartialUpdate
+                && matches!(document_template, Setting::Set(_))
+            {
+                return Err(
+                    crate::vector::error::NewEmbedderError::rest_document_template_and_fragments(
+                        indexing_fragments.len(),
+                        search_fragments.len(),
+                    ),
+                )
+                .map_err(|error| crate::UserError::VectorEmbeddingError(error.into()).into());
+            }
+            WithFragments::Yes { indexing_fragments, search_fragments }
+        } else if has_reset || context == EmbeddingValidationContext::FullSettings {
+            WithFragments::No
+        } else {
+            // if we are working with partial settings, the user could have changed only the `request` and not given again the fragments
+            WithFragments::Maybe
+        }
+    };
+    if let Some(request) = request.as_ref().set() {
+        let request = match with_fragments {
+            WithFragments::Yes { indexing_fragments, search_fragments } => {
+                crate::vector::rest::RequestData::new(
                     request.to_owned(),
                     indexing_fragments,
                     search_fragments,
                 )
-            .map_err(|error| crate::UserError::VectorEmbeddingError(error.into()))?;
+                .map_err(|error| crate::UserError::VectorEmbeddingError(error.into()))
+            }
+            WithFragments::No => crate::vector::rest::RequestData::new(
+                request.to_owned(),
+                Default::default(),
+                Default::default(),
+            )
+            .map_err(|error| crate::UserError::VectorEmbeddingError(error.into())),
+            WithFragments::Maybe => {
+                let mut indexing_fragments = BTreeMap::new();
+                indexing_fragments.insert("test".to_string(), serde_json::json!("test"));
+                crate::vector::rest::RequestData::new(
+                    request.to_owned(),
+                    indexing_fragments,
+                    Default::default(),
+                )
+                .or_else(|_| {
+                    crate::vector::rest::RequestData::new(
+                        request.to_owned(),
+                        Default::default(),
+                        Default::default(),
+                    )
+                })
+                .map_err(|error| crate::UserError::VectorEmbeddingError(error.into()))
+            }
+        }?;
         if let Some(response) = response.as_ref().set() {
             crate::vector::rest::Response::new(response.to_owned(), &request)
                 .map_err(|error| crate::UserError::VectorEmbeddingError(error.into()))?;
         }
     }
-    }
 
     let Some(inferred_source) = source.set() else {
         // we are validating the fused settings, so we always have a source