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

include/onnxruntime/core/session/onnxruntime_ep_c_api.h

@@ -1413,6 +1413,62 @@ struct OrtEpFactory {
    * \since Version 1.24.
    */
   ORT_API2_STATUS(SetEnvironmentOptions, _In_ OrtEpFactory* this_ptr, _In_ const OrtKeyValuePairs* options);
+
+  /** \brief Returns the number of OrtCustomOpDomains that this factory creates.
+   *
+   * \param[in] this_ptr The OrtEpFactory instance.
+   * \param[out] num_domains Output parameter set to the number of created 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 Creates the EP-specific OrtCustomOpDomains.
+   *
+   * This function is used when running inference on a model that contains EP-specific custom operations.
+   *
+   * Workflow:
+   * 1. The EP implements this function to supply a list of OrtCustomOpDomain instances.
+   * 2. The application calls SessionOptionsAppendExecutionProvider_V2() with an OrtEpDevice containing
+   *    the plugin EP's factory.
+   * 3. SessionOptionsAppendExecutionProvider_V2() appends the provided OrtCustomOpDomain list to the
+   *    session options.
+   *
+   * 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
+   *    - This Example EP demonstrates this approach.
+   *    - 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: EP has the responsibility to release OrtCustomOpDomain instances it creates. It happens
+   *       automatically if using ORT C++ api.
+   *
+   * \param[in] this_ptr The OrtEpFactory instance.
+   * \param[out] domains Pre-allocated array of `num_domains` elements by ORT that should be filled with
+                         OrtCustomOpDomain created by the EP.
+   * \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(CreateCustomOpDomains, _In_ OrtEpFactory* this_ptr,
+                  _Outptr_result_maybenull_ OrtCustomOpDomain** domains, _In_ size_t num_domains);
 };
 
 #ifdef __cplusplus

onnxruntime/core/session/onnxruntime_c_api.cc

@@ -3332,7 +3332,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

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

onnxruntime/core/session/utils.cc

@@ -482,7 +482,8 @@
 Status AddEpOptionsToSessionOptions(gsl::span<const OrtEpDevice* const> ep_devices,
                                     gsl::span<const char* const> ep_option_keys,
                                     gsl::span<const char* const> ep_option_vals,
-                                    SessionOptions& session_options) {
+                                    OrtSessionOptions& ort_session_options) {
+  SessionOptions& session_options = ort_session_options.value;
   const size_t num_ep_options = ep_option_keys.size();
   if (ep_option_vals.size() != num_ep_options) {
     return ORT_MAKE_STATUS(ONNXRUNTIME, INVALID_ARGUMENT,
@@ -505,6 +506,46 @@
 
       ORT_RETURN_IF_ERROR(config_options.AddConfigEntry((prefix + ep_option_keys[j]).c_str(), ep_option_vals[j]));
     }
+
+    // Add custom op domain provided by EP to the session options if any.
+    // OrtEpFactory::GetNumCustomOpDomains and OrtEpFactory::CreateCustomOpDomains
+    // were added in ORT 1.24.
+    OrtEpFactory* ep_factory = ep_device->ep_factory;
+    if (ep_factory &&
+        ep_factory->ort_version_supported >= 24 &&
+        ep_factory->GetNumCustomOpDomains != nullptr &&
+        ep_factory->CreateCustomOpDomains != nullptr) {
+      auto is_already_in_domains =
+          [&](const std::string& domain_name, const std::vector<OrtCustomOpDomain*>& domains) {
+            for (auto ptr : domains) {
+              if (domain_name == ptr->domain_) {
+                return true;
+              }
+            }
+            return false;
+          };
+
+      size_t num_domains = 0;
+      ORT_RETURN_IF_ERROR(ToStatusAndRelease(ep_factory->GetNumCustomOpDomains(ep_factory, &num_domains)));
+
+      InlinedVector<OrtCustomOpDomain*> domains;
+      domains.resize(num_domains);
+
+      ORT_RETURN_IF_ERROR(ToStatusAndRelease(ep_factory->CreateCustomOpDomains(ep_factory,
+                                                                               domains.data(),
+                                                                               domains.size())));
+
+      const auto domains_span = gsl::span<OrtCustomOpDomain*>(domains.data(), domains.size());
+      for (auto domain : domains_span) {
+        if (!is_already_in_domains(domain->domain_, ort_session_options.custom_op_domains_) &&
+            domain->custom_ops_.size() > 0) {
+          ort_session_options.custom_op_domains_.push_back(domain);
+        } else {
+          LOGS_DEFAULT(WARNING) << "The custom op domain name "
+                                << domain->domain_ << " is already in the session option. Skip it.";
+        }
+      }
+    }
   }
 
   return Status::OK();

onnxruntime/core/session/utils.h

@@ -69,7 +69,7 @@ Status CreateIExecutionProviderFactoryForEpDevices(const Environment& env,
 Status AddEpOptionsToSessionOptions(gsl::span<const OrtEpDevice* const> ep_devices,
                                     gsl::span<const char* const> ep_options_keys,
                                     gsl::span<const char* const> ep_options_vals,
-                                    SessionOptions& session_options);
+                                    OrtSessionOptions& session_options);
 
 }  // namespace onnxruntime
 #endif  // !defined(ORT_MINIMAL_BUILD)

onnxruntime/python/onnxruntime_pybind_state.cc

@@ -1346,7 +1346,7 @@ static Status AddEpFactoryFromEpDevices(PySessionOptions& py_sess_options,
   ORT_RETURN_IF_ERROR(AddEpOptionsToSessionOptions(ep_devices,
                                                    ep_option_keys,
                                                    ep_option_vals,
-                                                   py_sess_options.value));
+                                                   py_sess_options));
 
   py_sess_options.provider_factories.push_back(std::move(provider_factory));
   return Status::OK();