[EP ABI] Add CreateCustomOpDomains() API for plugin EP to register custom ops

include/onnxruntime/core/session/onnxruntime_ep_c_api.h

@@ -2060,6 +2060,64 @@ struct OrtEpFactory {
   ORT_API2_STATUS(CreateExternalResourceImporterForDevice, _In_ OrtEpFactory* this_ptr,
                   _In_ const OrtEpDevice* ep_device,
                   _Outptr_result_maybenull_ OrtExternalResourceImporterImpl** out_importer);
+
+  /** \brief Returns the number of OrtCustomOpDomains that this factory provides.
+   *
+   * \param[in] this_ptr The OrtEpFactory instance.
+   * \param[out] num_domains Output parameter set to the number of provided OrtCustomOpDomain instances.
+   *
+   * \snippet{doc} snippets.dox OrtStatus Return Value
+   *
+   * \since Version 1.24.
+   */
+  ORT_API2_STATUS(GetNumCustomOpDomains, _In_ OrtEpFactory* this_ptr, _Out_ size_t* num_domains);
+
+  /** \brief Gets the EP-specific OrtCustomOpDomains.
+   *
+   * This function is used when running inference on a model that contains EP-specific custom operations.
+   *
+   * Workflow:
+   * 1. The EP factory implements this function to supply a list of OrtCustomOpDomain instances.
+   * 2. The application either 1) calls SessionOptionsAppendExecutionProvider_V2() with an OrtEpDevice containing
+   *    the plugin EP's factory or 2) enables auto ep selection.
+   * 3. 1) SessionOptionsAppendExecutionProvider_V2() appends the provided OrtCustomOpDomains to the
+   *    session options or 2) ORT registers the OrtCustomOpDomains provided by the selected EP devices.
+   *
+   * As a result, any session created from these session options will have these custom op domains registered
+   * in ORT, ensuring that the custom ops are properly recognized and validated when the model is loaded.
+   *
+   * Plugin EPs can provide two types of custom ops:
+   *  1. A full OrtCustomOp with a concrete kernel implementation
+   *    - A Plugin EP can supply an OrtCustomOp and a corresponding CustomKernel::Compute() implementation.
+   *    - In GetCapability(), it calls EpGraphSupportInfo_AddSingleNode() to inform ORT
+   *      that the custom node should NOT be fused or compiled. Instead, ORT should invoke
+   *      the custom node's Compute() function at runtime.
+   *
+   *  2. A "placeholder" OrtCustomOp with an empty kernel implementation
+   *    - A compile-based Plugin EP can supply an OrtCustomOp whose CustomKernel::Compute()
+   *      does nothing. The purpose is to satisfy model validation during model loading by
+   *      registering the custom op as a valid operator in the session.
+   *    - In GetCapability(), the EP should call EpGraphSupportInfo_AddNodesToFuse() to
+   *      notify ORT that this custom node should be fused and compiled by the EP.
+   *    - In Compile(), the EP executes its compiled bits to perform inference for
+   *      the fused custom node.
+   *
+   * Note: The OrtCustomOpDomain instances must be valid while any session is using them.
+           EP factory has the responsibility to release OrtCustomOpDomain instances it creates. It happens
+   *       automatically if using the C++ Ort::CustomOpDomain class.
+   *
+   * \param[in] this_ptr The OrtEpFactory instance.
+   * \param[out] domains Array of `num_domains` elements pre-allocated by ORT that should be filled with
+                         OrtCustomOpDomain instances created by the EP. The `num_domains` is the value returned by
+                         GetNumCustomOpDomains(). The implementation is expected to treat `domains` as a buffer.
+   * \param[in] num_domains The size of the `domains` array pre-allocated by ORT.
+   *
+   * \snippet{doc} snippets.dox OrtStatus Return Value
+   *
+   * \since Version 1.24.
+   */
+  ORT_API2_STATUS(GetCustomOpDomains, _In_ OrtEpFactory* this_ptr,
+                  _Out_writes_all_(num_domains) OrtCustomOpDomain** domains, _In_ size_t num_domains);
 };
 
 #ifdef __cplusplus

onnxruntime/core/session/inference_session.h

@@ -662,6 +662,22 @@
     return session_id_;
   }
 
+  void SetExecutionDevices(std::vector<const OrtEpDevice*> execution_devices) {
+    execution_devices_ = std::move(execution_devices);
+  }
+
+  const std::vector<const OrtEpDevice*>& GetExecutionDevices() noexcept {
+    return execution_devices_;
+  }
+
+  void SetSelectedDevices(std::vector<const OrtEpDevice*> selected_devices) {
+    devices_selected_ = std::move(selected_devices);
+  }
+
+  const std::vector<const OrtEpDevice*>& GetSelectedDevices() noexcept {
+    return devices_selected_;
+  }
+
  protected:
 #if !defined(ORT_MINIMAL_BUILD)
 
@@ -1054,6 +1070,13 @@
   // Enable nodestats collection
   std::optional<NodeStatsRecorder> node_stats_recorder_;
 #endif
+
+  // Holds the list of devices from the environment, ordered via OrderDevices().
+  // It's used for auto ep selection.
+  std::vector<const OrtEpDevice*> execution_devices_;
+
+  // Holds the list of devices selected by policies.
+  std::vector<const OrtEpDevice*> devices_selected_;
 };
 
 struct SessionIOBinding {

onnxruntime/core/session/onnxruntime_c_api.cc

@@ -3333,7 +3333,7 @@ ORT_API_STATUS_IMPL(OrtApis::SessionOptionsAppendExecutionProvider_V2, _In_ OrtS
       ep_devices_span,
       ep_option_keys_span,
       ep_option_vals_span,
-      session_options->value));
+      *session_options));
 
   session_options->provider_factories.push_back(std::move(provider_factory));
 

onnxruntime/core/session/plugin_ep/ep_factory_internal_impl.h

@@ -102,6 +102,18 @@ class EpFactoryInternalImpl {
     return nullptr;
   }
 
+  virtual OrtStatus* GetNumCustomOpDomains(_Out_ size_t* num_domains) const noexcept {
+    *num_domains = 0;
+    return nullptr;
+  }
+
+  virtual OrtStatus* GetCustomOpDomains(_Out_writes_all_(num_domains) OrtCustomOpDomain** domains,
+                                        _In_ size_t num_domains) const noexcept {
+    ORT_UNUSED_PARAMETER(domains);
+    ORT_UNUSED_PARAMETER(num_domains);
+    return nullptr;
+  }
+
   // Function ORT calls to release an EP instance.
   void ReleaseEp(OrtEp* ep);
 

onnxruntime/core/session/provider_policy_context.cc

@@ -50,6 +50,7 @@
   return d->device->type == OrtHardwareDeviceType::OrtHardwareDeviceType_CPU &&
          d->ep_vendor == "Microsoft";
 }
+}  // namespace
 
 // Sort devices. NPU -> GPU -> CPU
 // Within in type, vendor owned, not.
@@ -115,16 +116,10 @@
   return sorted_devices;
 }
 
-OrtKeyValuePairs GetModelMetadata(const InferenceSession& session) {
+OrtKeyValuePairs GetModelMetadataKeyValuePairs(const ModelMetadata& model_metadata) {
   OrtKeyValuePairs metadata;
-  auto status_and_metadata = session.GetModelMetadata();
-
-  if (!status_and_metadata.first.IsOK()) {
-    return metadata;
-  }
 
   // use field names from onnx.proto
-  const auto& model_metadata = *status_and_metadata.second;
   metadata.Add("producer_name", model_metadata.producer_name);
   metadata.Add("producer_version", model_metadata.producer_version);
   metadata.Add("domain", model_metadata.domain);
@@ -138,88 +133,42 @@
 
   return metadata;
 }
-}  // namespace
+
+OrtKeyValuePairs GetModelMetadataFromSession(const InferenceSession& session) {
+  OrtKeyValuePairs metadata;
+  auto status_and_metadata = session.GetModelMetadata();
+
+  if (!status_and_metadata.first.IsOK()) {
+    return metadata;
+  }
+
+  const auto& model_metadata = *status_and_metadata.second;
+  return GetModelMetadataKeyValuePairs(model_metadata);
+}
 
 // Select execution providers based on the device policy and available devices and add to session
 Status ProviderPolicyContext::SelectEpsForSession(const Environment& env, const OrtSessionOptions& options,
                                                   InferenceSession& sess) {
-  // Get the list of devices from the environment and order them.
-  // Ordered by preference within each type. NPU -> GPU -> NPU
-  // TODO: Should environment.cc do the ordering?
-  std::vector<const OrtEpDevice*> execution_devices = OrderDevices(env.GetOrtEpDevices());
+  std::vector<const OrtEpDevice*> execution_devices;
+
+  // Check if the sorted list of devices has cached in the session
+  if (!sess.GetExecutionDevices().empty()) {
+    execution_devices = sess.GetExecutionDevices();
+  } else {
+    // Get the list of devices from the environment and order them.
+    // Ordered by preference within each type. NPU -> GPU -> NPU
+    // TODO: Should environment.cc do the ordering?
+    execution_devices = OrderDevices(env.GetOrtEpDevices());
+  }
 
   // The list of devices selected by policies
   std::vector<const OrtEpDevice*> devices_selected;
 
-  // Run the delegate if it was passed in lieu of any other policy
-  if (options.value.ep_selection_policy.delegate) {
-    auto model_metadata = GetModelMetadata(sess);
-    OrtKeyValuePairs runtime_metadata;  // TODO: where should this come from?
-
-    std::vector<const OrtEpDevice*> delegate_devices(execution_devices.begin(), execution_devices.end());
-    std::array<const OrtEpDevice*, 8> selected_devices{nullptr};
-    size_t num_selected = 0;
-
-    EpSelectionDelegate delegate = options.value.ep_selection_policy.delegate;
-    auto* status = delegate(delegate_devices.data(), delegate_devices.size(),
-                            &model_metadata, &runtime_metadata,
-                            selected_devices.data(), selected_devices.size(), &num_selected,
-                            options.value.ep_selection_policy.state);
-
-    // return or fall-through for both these cases
-    // going with explicit failure for now so it's obvious to user what is happening
-    if (status != nullptr) {
-      std::string delegate_error_msg = OrtApis::GetErrorMessage(status);  // copy
-      OrtApis::ReleaseStatus(status);
-
-      return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "EP selection delegate failed: ", delegate_error_msg);
-    }
-
-    if (num_selected == 0) {
-      return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "EP selection delegate did not select anything.");
-    }
-
-    if (num_selected > selected_devices.size()) {
-      return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL,
-                             "EP selection delegate selected too many EP devices (", num_selected, "). ",
-                             "The limit is ", selected_devices.size(), " EP devices.");
-    }
-
-    // Copy the selected devices to the output vector
-    devices_selected.reserve(num_selected);
-    for (size_t i = 0; i < num_selected; ++i) {
-      devices_selected.push_back(selected_devices[i]);
-    }
+  // Check if the list of devices has been selected and cached in the session
+  if (!sess.GetSelectedDevices().empty()) {
+    devices_selected = sess.GetSelectedDevices();
   } else {
-    // Create the selector for the chosen policy
-    std::unique_ptr<IEpPolicySelector> selector;
-    switch (options.value.ep_selection_policy.policy) {
-      case OrtExecutionProviderDevicePolicy_DEFAULT:
-        selector = std::make_unique<DefaultEpPolicy>();
-        break;
-      case OrtExecutionProviderDevicePolicy_PREFER_CPU:
-        selector = std::make_unique<PreferCpuEpPolicy>();
-        break;
-      case OrtExecutionProviderDevicePolicy_PREFER_NPU:
-      case OrtExecutionProviderDevicePolicy_MAX_EFFICIENCY:
-      case OrtExecutionProviderDevicePolicy_MIN_OVERALL_POWER:
-        selector = std::make_unique<PreferNpuEpPolicy>();
-        break;
-      case OrtExecutionProviderDevicePolicy_PREFER_GPU:
-      case OrtExecutionProviderDevicePolicy_MAX_PERFORMANCE:
-        selector = std::make_unique<PreferGpuEpPolicy>();
-        break;
-    }
-
-    // Execute policy
-
-    selector->SelectProvidersForDevices(execution_devices, devices_selected);
-  }
-
-  // Fail if we did not find any device matches
-  if (devices_selected.empty()) {
-    return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL,
-                           "No execution providers selected. Please check the device policy and available devices.");
+    ORT_RETURN_IF_ERROR(SelectEpDevices(options, execution_devices, devices_selected, nullptr, sess));
   }
 
   // Log telemetry for auto EP selection
@@ -314,6 +263,98 @@
     }
   }
 
+  if (sess.GetExecutionDevices().empty()) {
+    sess.SetExecutionDevices(execution_devices);
+  }
+
+  if (sess.GetSelectedDevices().empty()) {
+    sess.SetSelectedDevices(devices_selected);
+  }
+
+  return Status::OK();
+}
+
+Status ProviderPolicyContext::SelectEpDevices(const OrtSessionOptions& options,
+                                              const std::vector<const OrtEpDevice*>& execution_devices,
+                                              std::vector<const OrtEpDevice*>& devices_selected,
+                                              const OrtKeyValuePairs* metadata_from_model,
+                                              const InferenceSession& sess) {
+  // Run the delegate if it was passed in lieu of any other policy
+  if (options.value.ep_selection_policy.delegate) {
+    OrtKeyValuePairs model_metadata;
+
+    if (metadata_from_model) {
+      model_metadata = *metadata_from_model;
+    } else {
+      model_metadata = GetModelMetadataFromSession(sess);
+    }
+    OrtKeyValuePairs runtime_metadata;  // TODO: where should this come from?
+
+    std::vector<const OrtEpDevice*> delegate_devices(execution_devices.begin(), execution_devices.end());
+    std::array<const OrtEpDevice*, 8> selected_devices{nullptr};
+    size_t num_selected = 0;
+
+    EpSelectionDelegate delegate = options.value.ep_selection_policy.delegate;
+    auto* status = delegate(delegate_devices.data(), delegate_devices.size(),
+                            &model_metadata, &runtime_metadata,
+                            selected_devices.data(), selected_devices.size(), &num_selected,
+                            options.value.ep_selection_policy.state);
+
+    // return or fall-through for both these cases
+    // going with explicit failure for now so it's obvious to user what is happening
+    if (status != nullptr) {
+      std::string delegate_error_msg = OrtApis::GetErrorMessage(status);  // copy
+      OrtApis::ReleaseStatus(status);
+
+      return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "EP selection delegate failed: ", delegate_error_msg);
+    }
+
+    if (num_selected == 0) {
+      return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "EP selection delegate did not select anything.");
+    }
+
+    if (num_selected > selected_devices.size()) {
+      return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL,
+                             "EP selection delegate selected too many EP devices (", num_selected, "). ",
+                             "The limit is ", selected_devices.size(), " EP devices.");
+    }
+
+    // Copy the selected devices to the output vector
+    devices_selected.reserve(num_selected);
+    for (size_t i = 0; i < num_selected; ++i) {
+      devices_selected.push_back(selected_devices[i]);
+    }
+  } else {
+    // Create the selector for the chosen policy
+    std::unique_ptr<IEpPolicySelector> selector;
+    switch (options.value.ep_selection_policy.policy) {
+      case OrtExecutionProviderDevicePolicy_DEFAULT:
+        selector = std::make_unique<DefaultEpPolicy>();
+        break;
+      case OrtExecutionProviderDevicePolicy_PREFER_CPU:
+        selector = std::make_unique<PreferCpuEpPolicy>();
+        break;
+      case OrtExecutionProviderDevicePolicy_PREFER_NPU:
+      case OrtExecutionProviderDevicePolicy_MAX_EFFICIENCY:
+      case OrtExecutionProviderDevicePolicy_MIN_OVERALL_POWER:
+        selector = std::make_unique<PreferNpuEpPolicy>();
+        break;
+      case OrtExecutionProviderDevicePolicy_PREFER_GPU:
+      case OrtExecutionProviderDevicePolicy_MAX_PERFORMANCE:
+        selector = std::make_unique<PreferGpuEpPolicy>();
+        break;
+    }
+
+    // Execute policy
+
+    selector->SelectProvidersForDevices(execution_devices, devices_selected);
+  }
+
+  // Fail if we did not find any device matches
+  if (devices_selected.empty()) {
+    return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL,
+                           "No execution providers selected. Please check the device policy and available devices.");
+  }
   return Status::OK();
 }
 

onnxruntime/core/session/provider_policy_context.h

@@ -7,6 +7,7 @@
 
 #include "core/session/abi_session_options_impl.h"
 #include "core/session/environment.h"
+#include "core/session/inference_session.h"
 #include "core/session/onnxruntime_c_api.h"  // For OrtExecutionProviderDevicePolicy
 
 namespace onnxruntime {
@@ -41,6 +42,9 @@
   ProviderPolicyContext() = default;
 
   Status SelectEpsForSession(const Environment& env, const OrtSessionOptions& options, InferenceSession& sess);
+  Status SelectEpDevices(const OrtSessionOptions& options, const std::vector<const OrtEpDevice*>& execution_devices,
+                         std::vector<const OrtEpDevice*>& devices_selected, const OrtKeyValuePairs* model_metadata,
+                         const InferenceSession& sess);
   Status AddEpDefaultOptionsToSession(InferenceSession& sess, std::vector<const OrtEpDevice*> devices);
   void RemoveOrtCpuDevice(std::vector<const OrtEpDevice*>& devices);
   Status CreateExecutionProvider(const Environment& env, OrtSessionOptions& options, const OrtLogger& logger,
@@ -75,6 +79,10 @@
                                  std::vector<const OrtEpDevice*>& selected_devices) override;
 };
 
+std::vector<const OrtEpDevice*> OrderDevices(const std::vector<const OrtEpDevice*>& devices);
+
+OrtKeyValuePairs GetModelMetadataKeyValuePairs(const ModelMetadata& session);
+
 }  // namespace onnxruntime
 
 #endif  // !ORT_MINIMAL_BUILD