Revert endpoint creation validation for ELSER and E5

Author: dan-rubinstein

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;
     }
 }

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);
         }
     }