Fix early check that prevents a compiled model from being overwritten (#26439)

### Description
Fixes #26294

When using the old model compilation approach (session option
configuration), ORT should verify that the generated output model does
not already exist. Importantly, this check should be done _before_
calling an EP's compile() method. This PR fixes this check, which was
unintentionally disabled by a [previous
PR.](#25455).

Note that this check also (correctly) happens _after_ calling the EP's
compile() method, but it is better to catch it early if we can.



### Motivation and Context
Fixes a regression in the older compilation workflow.

Author: adrianlizarraga

onnxruntime/core/framework/ep_context_options.cc

@@ -15,15 +15,15 @@ namespace epctx {
 
 ModelGenOptions::ModelGenOptions() = default;
 
+// This constructor is only used when using the older compilation approach that uses
+// session configuration options to enable and configure compilation (i.e., not OrtCompileApi).
+// This initializes ModelGenOptions from the session config options.
 ModelGenOptions::ModelGenOptions(const ConfigOptions& config_options) {
   enable = config_options.GetConfigOrDefault(kOrtSessionOptionEpContextEnable, "0") == "1";
 
-  std::string output_model_path = config_options.GetConfigOrDefault(kOrtSessionOptionEpContextFilePath, "");
-  if (!output_model_path.empty()) {
-    output_model_location = std::filesystem::path(output_model_path);
-  } else {
-    output_model_location = std::monostate{};
-  }
+  // Note: the older compilation approach only supports compiling to an output file.
+  output_model_location = std::filesystem::path(
+      config_options.GetConfigOrDefault(kOrtSessionOptionEpContextFilePath, ""));
 
   std::string external_initializers_file_path = config_options.GetConfigOrDefault(
       kOrtSessionOptionsEpContextModelExternalInitializersFileName, "");

onnxruntime/core/session/utils.cc

@@ -134,18 +134,29 @@ static OrtStatus* CreateSessionAndLoadModelImpl(_In_ const OrtSessionOptions* op
   bool load_config_from_model =
       os_env.GetEnvironmentVar(inference_session_utils::kOrtLoadConfigFromModelEnvVar) == "1";
 
-  // If ep.context_enable is set, then ep.context_file_path is expected, otherwise ORT don't know where to generate the _ctx.onnx file
+  // Check EPContext model generation options when the input model is loaded from memory (no input model path).
   if (options && model_path == nullptr) {
     epctx::ModelGenOptions ep_ctx_gen_options = options->value.GetEpContextGenerationOptions();
 
-    // This is checked by the OrtCompileApi's CompileModel() function, but we check again here in case
-    // the user used the older SessionOptions' configuration entries to generate a compiled model.
-    if (ep_ctx_gen_options.enable && !ep_ctx_gen_options.HasOutputModelLocation()) {
-      return OrtApis::CreateStatus(ORT_FAIL,
-                                   "Inference session was configured with EPContext model generation enabled but "
-                                   "without a valid location (e.g., file or buffer) for the output model. "
-                                   "Please specify a valid ep.context_file_path via SessionOption configs "
-                                   "or use the OrtCompileApi to compile a model to a file or buffer.");
+    if (ep_ctx_gen_options.enable) {
+      auto* output_model_path = ep_ctx_gen_options.TryGetOutputModelPath();
+
+      // If the user does not provide an output model location, ORT normally generates an output model file path based
+      // on the input model's path (i.e., replace ".onnx" with "_ctx.onnx"). However, because there is no input model
+      // path, we require the application to explicitly set the output model's location.
+      //
+      // Note: This is checked by the OrtCompileApi's CompileModel() function, but we check again here in case
+      // the user used the older SessionOptions' configuration entries to generate a compiled model.
+      if (!ep_ctx_gen_options.HasOutputModelLocation() ||               // No output model location (file, buffer, etc.)
+          (output_model_path != nullptr && output_model_path->empty())  // Has an output file, but it is empty.
+      ) {
+        return OrtApis::CreateStatus(ORT_FAIL,
+                                     "Inference session with a model loaded from bytes was configured with EPContext "
+                                     "model generation enabled but without a valid location (e.g., file or buffer) "
+                                     "for the output model. Please specify a valid ep.context_file_path via "
+                                     "SessionOption configs or use the OrtCompileApi to compile a model to a "
+                                     "file or buffer.");
+      }
     }
   }
 

onnxruntime/test/autoep/test_execution.cc

@@ -10,6 +10,7 @@
 #include <gtest/gtest.h>
 
 #include "core/session/onnxruntime_cxx_api.h"
+#include "core/session/onnxruntime_session_options_config_keys.h"
 
 #include "test/autoep/test_autoep_utils.h"
 #include "test/shared_lib/utils.h"
@@ -184,6 +185,62 @@ TEST(OrtEpLibrary, PluginEp_VirtGpu_GenEpContextModel) {
     ASSERT_TRUE(std::filesystem::exists(output_model_file));
   }
 }
+
+// Uses the original compiling approach with session option configs (instead of explicit compile API).
+// Test that ORT does not overwrite an output model if it already exists.
+// Notably, this tests the case in which ORT automatically generates the output model name.
+TEST(OrtEpLibrary, PluginEp_GenEpContextModel_ErrorOutputModelExists_AutoGenOutputModelName) {
+  const ORTCHAR_T* input_model_file = ORT_TSTR("testdata/mul_1.onnx");
+  const ORTCHAR_T* expected_output_model_file = ORT_TSTR("testdata/mul_1_ctx.onnx");
+  std::filesystem::remove(expected_output_model_file);
+
+  RegisteredEpDeviceUniquePtr example_ep;
+  Utils::RegisterAndGetExampleEp(*ort_env, Utils::example_ep_info, example_ep);
+  Ort::ConstEpDevice plugin_ep_device(example_ep.get());
+  std::unordered_map<std::string, std::string> ep_options;
+
+  // Compile a model and let ORT set the output model name. This should succeed.
+  {
+    Ort::SessionOptions so;
+    so.AddConfigEntry(kOrtSessionOptionEpContextEnable, "1");
+    // Don't specify an output model path to let ORT automatically generate it!
+    // so.AddConfigEntry(kOrtSessionOptionEpContextFilePath, "");
+
+    so.AppendExecutionProvider_V2(*ort_env, {plugin_ep_device}, ep_options);
+
+    Ort::Session session(*ort_env, input_model_file, so);
+    ASSERT_TRUE(std::filesystem::exists(expected_output_model_file));  // check compiled model was generated.
+  }
+
+  auto modify_time_1 = std::filesystem::last_write_time(expected_output_model_file);
+
+  // Try compiling the model again. ORT should return an error because the output model already exists.
+  // Original compiled model should not be modified.
+  {
+    Ort::SessionOptions so;
+    so.AddConfigEntry(kOrtSessionOptionEpContextEnable, "1");
+    // Don't specify an output model path to let ORT automatically generate it!
+    // so.AddConfigEntry(kOrtSessionOptionEpContextFilePath, "");
+
+    so.AppendExecutionProvider_V2(*ort_env, {plugin_ep_device}, ep_options);
+
+    try {
+      Ort::Session session(*ort_env, input_model_file, so);
+      FAIL();  // Should not get here!
+    } catch (const Ort::Exception& excpt) {
+      ASSERT_EQ(excpt.GetOrtErrorCode(), ORT_FAIL);
+      ASSERT_THAT(excpt.what(),
+                  testing::HasSubstr("exists already. "
+                                     "Please remove the EP context model if you want to re-generate it."));
+
+      ASSERT_TRUE(std::filesystem::exists(expected_output_model_file));
+      auto modify_time_2 = std::filesystem::last_write_time(expected_output_model_file);
+      ASSERT_EQ(modify_time_2, modify_time_1);  // Check that file was not modified
+    }
+  }
+
+  std::filesystem::remove(expected_output_model_file);
+}
 }  // namespace test
 }  // namespace onnxruntime