Revert endpoint creation validation for ELSER and E5 (elastic#126792) (elastic#126801)

dan-rubinstein · elasticmachine · web-flow · commit 156d5da28e7c · 2025-04-16T03:43:30.000+10:00
* Revert endpoint creation validation for ELSER and E5

* Update docs/changelog/126792.yaml

* Revert start model deployment being in TransportPutInferenceModelAction

---------

Co-authored-by: Elastic Machine &lt;elasticmachine@users.noreply.github.com&gt;
diff --git a/docs/changelog/126792.yaml b/docs/changelog/126792.yaml
@@ -0,0 +1,5 @@
+pr: 126792
+summary: Revert endpoint creation validation for ELSER and E5
+area: Machine Learning
+type: bug
+issues: []
diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/action/TransportPutInferenceModelAction.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/action/TransportPutInferenceModelAction.java
@@ -195,23 +195,19 @@ private void parseAndStoreModel(
         ActionListener<Model> storeModelListener = listener.delegateFailureAndWrap(
             (delegate, verifiedModel) -> modelRegistry.storeModel(
                 verifiedModel,
-                ActionListener.wrap(
-                    r -> listener.onResponse(new PutInferenceModelAction.Response(verifiedModel.getConfigurations())),
-                    e -> {
-                        if (e.getCause() instanceof StrictDynamicMappingException
-                            && e.getCause().getMessage().contains("chunking_settings")) {
-                            delegate.onFailure(
-                                new ElasticsearchStatusException(
-                                    "One or more nodes in your cluster does not support chunking_settings. "
-                                        + "Please update all nodes in your cluster to the latest version to use chunking_settings.",
-                                    RestStatus.BAD_REQUEST
-                                )
-                            );
-                        } else {
-                            delegate.onFailure(e);
-                        }
+                ActionListener.wrap(r -> startInferenceEndpoint(service, timeout, verifiedModel, delegate), e -> {
+                    if (e.getCause() instanceof StrictDynamicMappingException && e.getCause().getMessage().contains("chunking_settings")) {
+                        delegate.onFailure(
+                            new ElasticsearchStatusException(
+                                "One or more nodes in your cluster does not support chunking_settings. "
+                                    + "Please update all nodes in your cluster to the latest version to use chunking_settings.",
+                                RestStatus.BAD_REQUEST
+                            )
+                        );
+                    } else {
+                        delegate.onFailure(e);
                     }
-                ),
+                }),
                 timeout
             )
         );
@@ -228,6 +224,19 @@ private void parseAndStoreModel(
         service.parseRequestConfig(inferenceEntityId, taskType, config, parsedModelListener);
     }
 
+    private void startInferenceEndpoint(
+        InferenceService service,
+        TimeValue timeout,
+        Model model,
+        ActionListener<PutInferenceModelAction.Response> listener
+    ) {
+        if (skipValidationAndStart) {
+            listener.onResponse(new PutInferenceModelAction.Response(model.getConfigurations()));
+        } else {
+            service.start(model, timeout, listener.map(started -> new PutInferenceModelAction.Response(model.getConfigurations())));
+        }
+    }
+
     private Map<String, Object> requestToMap(PutInferenceModelAction.Request request) throws IOException {
         try (
             XContentParser parser = XContentHelper.createParser(
diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidator.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidator.java
@@ -9,51 +9,91 @@
 
 import org.elasticsearch.ElasticsearchStatusException;
 import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.common.Strings;
 import org.elasticsearch.core.TimeValue;
 import org.elasticsearch.inference.InferenceService;
+import org.elasticsearch.inference.InferenceServiceResults;
 import org.elasticsearch.inference.Model;
+import org.elasticsearch.inference.TaskType;
 import org.elasticsearch.rest.RestStatus;
+import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults;
+import org.elasticsearch.xpack.core.inference.results.TextEmbeddingResults;
+import org.elasticsearch.xpack.inference.services.elasticsearch.CustomElandEmbeddingModel;
 
 public class ElasticsearchInternalServiceModelValidator implements ModelValidator {
 
-    ModelValidator modelValidator;
+    private final ServiceIntegrationValidator serviceIntegrationValidator;
 
-    public ElasticsearchInternalServiceModelValidator(ModelValidator modelValidator) {
-        this.modelValidator = modelValidator;
+    public ElasticsearchInternalServiceModelValidator(ServiceIntegrationValidator serviceIntegrationValidator) {
+        this.serviceIntegrationValidator = serviceIntegrationValidator;
     }
 
     @Override
     public void validate(InferenceService service, Model model, TimeValue timeout, ActionListener<Model> listener) {
-        service.start(model, timeout, ActionListener.wrap((modelDeploymentStarted) -> {
-            if (modelDeploymentStarted) {
-                try {
-                    modelValidator.validate(service, model, timeout, listener.delegateResponse((l, exception) -> {
-                        stopModelDeployment(service, model, l, exception);
-                    }));
-                } catch (Exception e) {
-                    stopModelDeployment(service, model, listener, e);
-                }
-            } else {
-                listener.onFailure(
-                    new ElasticsearchStatusException("Could not deploy model for inference endpoint", RestStatus.INTERNAL_SERVER_ERROR)
+        if (model instanceof CustomElandEmbeddingModel elandModel && elandModel.getTaskType() == TaskType.TEXT_EMBEDDING) {
+            var temporaryModelWithModelId = new CustomElandEmbeddingModel(
+                elandModel.getServiceSettings().modelId(),
+                elandModel.getTaskType(),
+                elandModel.getConfigurations().getService(),
+                elandModel.getServiceSettings(),
+                elandModel.getConfigurations().getChunkingSettings()
+            );
+
+            serviceIntegrationValidator.validate(
+                service,
+                temporaryModelWithModelId,
+                timeout,
+                listener.delegateFailureAndWrap((delegate, r) -> {
+                    delegate.onResponse(postValidate(service, model, r));
+                })
+            );
+        } else {
+            listener.onResponse(model);
+        }
+    }
+
+    private Model postValidate(InferenceService service, Model model, InferenceServiceResults results) {
+        if (results instanceof TextEmbeddingResults<?> embeddingResults) {
+            var serviceSettings = model.getServiceSettings();
+            var dimensions = serviceSettings.dimensions();
+            int embeddingSize = getEmbeddingSize(embeddingResults);
+
+            if (Boolean.TRUE.equals(serviceSettings.dimensionsSetByUser())
+                && dimensions != null
+                && (dimensions.equals(embeddingSize) == false)) {
+                throw new ElasticsearchStatusException(
+                    Strings.format(
+                        "The retrieved embeddings size [%s] does not match the size specified in the settings [%s]. "
+                            + "Please recreate the [%s] configuration with the correct dimensions",
+                        embeddingResults.getFirstEmbeddingSize(),
+                        serviceSettings.dimensions(),
+                        model.getInferenceEntityId()
+                    ),
+                    RestStatus.BAD_REQUEST
                 );
             }
-        }, listener::onFailure));
+
+            return service.updateModelWithEmbeddingDetails(model, embeddingSize);
+        } else {
+            throw new ElasticsearchStatusException(
+                "Validation call did not return expected results type."
+                    + "Expected a result of type ["
+                    + TextEmbeddingFloatResults.NAME
+                    + "] got ["
+                    + (results == null ? "null" : results.getWriteableName())
+                    + "]",
+                RestStatus.BAD_REQUEST
+            );
+        }
     }
 
-    private void stopModelDeployment(InferenceService service, Model model, ActionListener<Model> listener, Exception e) {
-        service.stop(
-            model,
-            ActionListener.wrap(
-                (v) -> listener.onFailure(e),
-                (ex) -> listener.onFailure(
-                    new ElasticsearchStatusException(
-                        "Model validation failed and model deployment could not be stopped",
-                        RestStatus.INTERNAL_SERVER_ERROR,
-                        ex
-                    )
-                )
-            )
-        );
+    private int getEmbeddingSize(TextEmbeddingResults<?> embeddingResults) {
+        int embeddingSize;
+        try {
+            embeddingSize = embeddingResults.getFirstEmbeddingSize();
+        } catch (Exception e) {
+            throw new ElasticsearchStatusException("Could not determine embedding size", RestStatus.BAD_REQUEST, e);
+        }
+        return embeddingSize;
     }
 }
diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/validation/ModelValidatorBuilder.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/validation/ModelValidatorBuilder.java
@@ -12,11 +12,10 @@
 
 public class ModelValidatorBuilder {
     public static ModelValidator buildModelValidator(TaskType taskType, boolean isElasticsearchInternalService) {
-        var modelValidator = buildModelValidatorForTaskType(taskType);
         if (isElasticsearchInternalService) {
-            return new ElasticsearchInternalServiceModelValidator(modelValidator);
+            return new ElasticsearchInternalServiceModelValidator(new SimpleServiceIntegrationValidator());
         } else {
-            return modelValidator;
+            return buildModelValidatorForTaskType(taskType);
         }
     }
 
diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidatorTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidatorTests.java

Original file line number	Diff line number	Diff line change
`@@ -12,11 +12,10 @@`
`12`	`12`
`13`	`13`	`public class ModelValidatorBuilder {`
`14`	`14`	`public static ModelValidator buildModelValidator(TaskType taskType, boolean isElasticsearchInternalService) {`
`15`		`- var modelValidator = buildModelValidatorForTaskType(taskType);`
`16`	`15`	`if (isElasticsearchInternalService) {`
`17`		`- return new ElasticsearchInternalServiceModelValidator(modelValidator);`
	`16`	`+ return new ElasticsearchInternalServiceModelValidator(new SimpleServiceIntegrationValidator());`
`18`	`17`	`} else {`
`19`		`- return modelValidator;`
	`18`	`+ return buildModelValidatorForTaskType(taskType);`
`20`	`19`	`}`
`21`	`20`	`}`
`22`	`21`