[EP ABI] Get EP compiled model compatibility

include/onnxruntime/core/framework/execution_provider.h

@@ -317,6 +317,13 @@
   virtual common::Status Compile(const std::vector<FusedNodeAndGraph>& fused_nodes_and_graphs,
                                  std::vector<NodeComputeInfo>& node_compute_funcs);
 
+  // TODO: add documentation comment.
+  virtual common::Status GetCompiledModelCompatibility(const onnxruntime::GraphViewer& /*graph_viewer*/,
+                                                       OrtCompiledModelCompatibility& compatibility) {
+    compatibility = OrtCompiledModelCompatibility_SUPPORT_UNKNOWN;
+    return common::Status::OK();
+  }
+
 #endif
 
   void SetLogger(const logging::Logger* logger) {

include/onnxruntime/core/session/onnxruntime_ep_c_api.h

@@ -335,6 +335,18 @@ typedef enum OrtEpDataLayout {
   OrtEpDataLayout_Default = OrtEpDataLayout_NCHW,
 } OrtEpDataLayout;
 
+/**
+ * \brief Enumeration describing the compatibility state of a compiled model.
+ *
+ * \since Version 1.23.
+ */
+typedef enum OrtCompiledModelCompatibility {
+  OrtCompiledModelCompatibility_SUPPORT_UNKNOWN = 0,
+  OrtCompiledModelCompatibility_SUPPORTED_OPTIMAL,
+  OrtCompiledModelCompatibility_SUPPORTED_PREFER_RECOMPILATION,
+  OrtCompiledModelCompatibility_UNSUPPORTED,
+} OrtCompiledModelCompatibility;
+
 /**
  * \brief The OrtEp struct provides functions to implement for an execution provider.
  * \since Version 1.22.
@@ -527,6 +539,27 @@ struct OrtEp {
   OrtStatus*(ORT_API_CALL* OnRunEnd)(_In_ OrtEp* this_ptr,
                                      _In_ const OrtRunOptions* run_options,
                                      _In_ bool sync_stream);
+
+  /** \brief Called by ORT to determine the compatibility of a compiled model with the EP.
+   *
+   * The application determines whether a given model compatibility (other than unsupported) should cause
+   * session-creation to fail.
+   *
+   * \param[in] this_ptr The OrtEp instance.
+   * \param[in] graph The top-level graph for the model.
+   * \param[out] model_compatibility Output parameter set to the OrtCompiledModelCompatibility enum value that
+   *                                 describes the compatibility of the model with the EP.
+   *
+   * \note Implementation of this function is optional. If not implemented, ORT assumes a result of
+   * OrtCompiledModelCompatibility_SUPPORT_UNKNOWN.
+   *
+   * \snippet{doc} snippets.dox OrtStatus Return Value
+   *
+   * \since Version 1.23.
+   */
+  OrtStatus*(ORT_API_CALL* GetCompiledModelCompatibility)(_In_ OrtEp* this_ptr,
+                                                          _In_ const OrtGraph* graph,
+                                                          _Out_ OrtCompiledModelCompatibility* model_compatibility);
 };
 
 /** \brief The function signature that ORT will call to create OrtEpFactory instances.

onnxruntime/core/session/ep_plugin_provider_interfaces.cc

@@ -574,4 +574,24 @@ std::vector<AllocatorPtr> PluginExecutionProvider::CreatePreferredAllocators() {
   return allocators;
 }
 
+Status PluginExecutionProvider::GetCompiledModelCompatibility(const onnxruntime::GraphViewer& graph_viewer,
+                                                              OrtCompiledModelCompatibility& compatibility) {
+  if (ort_ep_->GetCompiledModelCompatibility == nullptr) {
+    // Plugin EP did not provide an implementation of this function, so we call a default implementation.
+    return Base::GetCompiledModelCompatibility(graph_viewer, compatibility);
+  }
+
+  // Create EpGraph (extends OrtGraph) for the actual plugin EP to consume.
+  std::unique_ptr<EpGraph> ep_graph = nullptr;
+  ORT_RETURN_IF_ERROR(EpGraph::Create(graph_viewer, ep_graph));
+
+  // Call EP plugin's OrtEp::GetCompiledModelCompatibility() function.
+  OrtCompiledModelCompatibility ep_compatibility = OrtCompiledModelCompatibility_SUPPORT_UNKNOWN;
+  ORT_RETURN_IF_ERROR(ToStatusAndRelease(ort_ep_->GetCompiledModelCompatibility(ort_ep_.get(), ep_graph.get(),
+                                                                                &ep_compatibility)));
+
+  compatibility = ep_compatibility;
+  return Status::OK();
+}
+
 }  // namespace onnxruntime

onnxruntime/core/session/ep_plugin_provider_interfaces.h

@@ -99,6 +99,10 @@
   // needed based on matching against allocator_mem_infos_.
   std::vector<AllocatorPtr> CreatePreferredAllocators() override;
 
+  // TODO: Add documentation comment
+  Status GetCompiledModelCompatibility(const onnxruntime::GraphViewer& graph_viewer,
+                                       OrtCompiledModelCompatibility& compatibility) override;
+
  private:
   struct FusedNodeState {
     FusedNodeState() = default;

onnxruntime/test/framework/ep_plugin_provider_test.cc

@@ -317,4 +317,42 @@ TEST(PluginExecutionProviderTest, InferOrtDeviceFromDeviceMemoryInfo) {
 #endif  // !defined(ORT_NO_EXCEPTIONS)
 }
 
+TEST(PluginExecutionProviderTest, TestGetCompiledModelCompatibility) {
+  auto [ep_wrapper, ort_ep_plugin] = test_plugin_ep::MakeTestOrtEp();
+
+  // Test default behavior (EP plugin does not provide an implementation of the function).
+  {
+    ort_ep_plugin->GetCompiledModelCompatibility = nullptr;  // EP plugin doesn't implement. Should get default value.
+    OrtCompiledModelCompatibility compatibility = OrtCompiledModelCompatibility_SUPPORT_UNKNOWN;
+
+    // TODO: Need to load a model into a GraphViewer and pass it to this call.
+    // See how it is done in onnxruntime/test/ep_graph/test_ep_graph_utils.h.
+    // We can use the onnxruntime::Model class to load it.
+
+    // ASSERT_STATUS_OK(ep_wrapper->GetCompiledModelCompatibility(graph_viewer, compatibility));
+
+    ASSERT_EQ(compatibility, OrtCompiledModelCompatibility_SUPPORT_UNKNOWN);
+  }
+
+  // Test an EP plugin that provides a basic implementation that returns SUPPORTED_OPTIMAL.
+  {
+    auto get_compiled_model_compat = [](OrtEp* /*this_ptr*/, const OrtGraph* graph,
+                                        OrtCompiledModelCompatibility* compatibility) -> ::OrtStatus* {
+      (void)graph;
+      *compatibility = OrtCompiledModelCompatibility_SUPPORTED_OPTIMAL;
+      return nullptr;
+    };
+
+    ort_ep_plugin->GetCompiledModelCompatibility = get_compiled_model_compat;
+    OrtCompiledModelCompatibility compatibility = OrtCompiledModelCompatibility_SUPPORT_UNKNOWN;
+
+    // TODO: Need to load a model into a GraphViewer and pass it to this call.
+    // See how it is done in onnxruntime/test/ep_graph/test_ep_graph_utils.h.
+    // We can use the onnxruntime::Model class to load it.
+
+    // ASSERT_STATUS_OK(ep_wrapper->GetCompiledModelCompatibility(graph_viewer, compatibility));
+    // ASSERT_EQ(compatibility, OrtCompiledModelCompatibility_SUPPORTED_OPTIMAL);
+    (void)compatibility;
+  }
+}
 }  // namespace onnxruntime::test