[EP API] header-only adapter for EP API (#26919)

### Description

This PR adds a few headers for supporting building WebGPU EP and CUDA EP
as plugin EPs.

See summary of #26907

Author: fs-eire

include/onnxruntime/ep/README.md

@@ -0,0 +1,21 @@
+## EP adapter
+
+This folder contains a set of C++ header files. They are used specifically for allowing ONNX Runtime internal kernel-based EPs to use the plugin-style EP API while keep minimal changes to existing code.
+
+### Folder Structure
+
+There are 2 types of header files:
+
+- General header files for plugin EP. This may include utilities, macros and shared routines that depending on ONNX Runtime public API only. There are multiple places for header files of this category (which we are going to unify them to one place. There is an ongoing discussion about unifying shared headers for plugin EPs):
+  - `include/onnxruntime/ep/` (#26919)
+  - `onnxruntime/test/autoep/library/plugin_ep_utils.h`
+  - `include/onnxruntime/core/providers/utils/` (#25753)
+
+- Header files specifically used for supporting WebGPU EP and CUDA EP to use EP APIs. These header files do not only depend on ONNX Runtime public API, but also depend on ONNX Runtime internal headers. They define adapter classes that replace their compatible, internal ONNX Runtime equivalents.
+  - `include/onnxruntime/ep/adapter/`
+
+### Usage
+
+Make sure to include "ep/adapters.h" to include all adapter implementation code. This file brings the adapter classes into the EP's namespace, so it should be included before other EP code that relies on the adapter classes. Using "ep/adapters.h" as a pre-compiled header is the recommended way to include it first.
+
+`ep/adapters.h` has conflicts with shared provider. Shared provider should be disabled when using these adapters.

include/onnxruntime/ep/adapter/allocator.h

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#if !defined(ORT_EP_API_ADAPTER_HEADER_INCLUDED)
+#error "This header should not be included directly. Include ep/adapters.h instead."
+#endif
+
+#include "core/framework/allocator.h"
+
+namespace onnxruntime {
+namespace ep {
+namespace adapter {
+
+/// <summary>
+/// A bridge class between the EP API OrtAllocator and an IAllocator implementation.
+/// </summary>
+class Allocator : public OrtAllocator {
+ public:
+  explicit Allocator(const OrtMemoryInfo* memory_info, AllocatorPtr impl)
+      : OrtAllocator{}, memory_info_(memory_info), impl_(impl) {
+    version = ORT_API_VERSION;
+    Alloc = AllocImpl;
+    Free = FreeImpl;
+    Info = InfoImpl;
+  }
+
+ private:
+  static void* ORT_API_CALL AllocImpl(OrtAllocator* this_ptr, size_t size) noexcept {
+    auto* allocator = static_cast<Allocator*>(this_ptr);
+    return allocator->impl_->Alloc(size);
+  }
+
+  static void ORT_API_CALL FreeImpl(OrtAllocator* this_ptr, void* p) noexcept {
+    auto* allocator = static_cast<Allocator*>(this_ptr);
+    allocator->impl_->Free(p);
+  }
+
+  static const OrtMemoryInfo* ORT_API_CALL InfoImpl(const OrtAllocator* this_ptr) noexcept {
+    auto* allocator = static_cast<const Allocator*>(this_ptr);
+    return allocator->memory_info_;
+  }
+
+  const OrtMemoryInfo* memory_info_;
+  AllocatorPtr impl_;
+};
+
+}  // namespace adapter
+}  // namespace ep
+}  // namespace onnxruntime

include/onnxruntime/ep/adapter/data_transfer_manager.h

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#if !defined(ORT_EP_API_ADAPTER_HEADER_INCLUDED)
+#error "This header should not be included directly. Include ep/adapters.h instead."
+#endif
+
+#include "core/common/status.h"
+#include "core/common/common.h"
+#include "core/framework/data_transfer.h"
+#include "core/framework/tensor.h"
+
+namespace onnxruntime {
+namespace ep {
+namespace adapter {
+
+/// <summary>
+/// An adapter class partially implementing the interface of `onnxruntime::DataTransferManager`.
+/// </summary>
+struct DataTransferManager {
+  explicit DataTransferManager(std::unique_ptr<IDataTransfer> impl) : impl_{std::move(impl)} {}
+
+  common::Status CopyTensor(const Tensor& src, Tensor& dst) const {
+    if (src.Shape().Size() != dst.Shape().Size()) {
+      return ORT_MAKE_STATUS(ONNXRUNTIME,
+                             FAIL,
+                             "Tensor size mismatch: source tensor size is ",
+                             src.Shape().Size(),
+                             ", destination tensor size is ",
+                             dst.Shape().Size());
+    }
+
+    if (impl_->CanCopy(src.Location().device, dst.Location().device)) {
+      return impl_->CopyTensor(src, dst);
+    }
+
+    return ORT_MAKE_STATUS(ONNXRUNTIME,
+                           FAIL,
+                           "There's no data transfer registered for copying tensors from ",
+                           src.Location().device.ToString(),
+                           " to ",
+                           dst.Location().device.ToString());
+  }
+
+ private:
+  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(DataTransferManager);
+  std::unique_ptr<IDataTransfer> impl_;
+};
+
+}  // namespace adapter
+}  // namespace ep
+}  // namespace onnxruntime

include/onnxruntime/ep/adapter/ep.h

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#if !defined(ORT_EP_API_ADAPTER_HEADER_INCLUDED)
+#error "This header should not be included directly. Include ep/adapters.h instead."
+#endif
+
+#include "data_transfer_manager.h"
+
+#include "core/framework/execution_provider.h"
+
+namespace onnxruntime {
+namespace ep {
+namespace adapter {
+
+/// <summary>
+/// Wrapper around IExecutionProvider to expose via OrtEp.
+/// </summary>
+class Ep : public OrtEp {
+ protected:
+  explicit Ep(std::unique_ptr<IExecutionProvider> impl, AllocatorPtr temp_space_cpu_allocator, AllocatorPtr temp_space_allocator)
+      : OrtEp{},
+        impl_(std::move(impl)),
+        data_transfer_manager_{impl_->GetDataTransfer()},
+        profiler_{impl_->GetProfiler()},
+        temp_space_cpu_allocator_{temp_space_cpu_allocator},
+        temp_space_allocator_{temp_space_allocator} {
+  }
+
+ public:
+  inline IExecutionProvider* EpImpl() const noexcept {
+    return impl_.get();
+  }
+  inline const DataTransferManager& GetDataTransferManager() const noexcept {
+    return data_transfer_manager_;
+  }
+  Status GetTempSpaceCPUAllocator(AllocatorPtr* output) const {
+    *output = temp_space_cpu_allocator_;
+    return Status::OK();
+  }
+  Status GetTempSpaceAllocator(AllocatorPtr* output) const {
+    *output = temp_space_allocator_;
+    return Status::OK();
+  }
+
+ private:
+  std::unique_ptr<IExecutionProvider> impl_;
+  DataTransferManager data_transfer_manager_;
+  std::unique_ptr<profiling::EpProfiler> profiler_;
+  AllocatorPtr temp_space_cpu_allocator_;
+  AllocatorPtr temp_space_allocator_;
+};
+
+}  // namespace adapter
+}  // namespace ep
+}  // namespace onnxruntime

include/onnxruntime/ep/adapter/kernel_def.h

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#if !defined(ORT_EP_API_ADAPTER_HEADER_INCLUDED)
+#error "This header should not be included directly. Include ep/adapters.h instead."
+#endif
+
+#include <memory>
+
+namespace onnxruntime {
+namespace ep {
+namespace adapter {
+
+/// <summary>
+/// An adapter class partially implementing the interface of `onnxruntime::KernelDef`.
+/// </summary>
+class KernelDef {
+ public:
+  explicit KernelDef(const OrtKernelInfo* kernel_info) : kernel_info_{kernel_info} {}
+
+  const std::string OpName() const {
+    return kernel_info_.GetNodeName();
+  }
+
+  const std::string Domain() const {
+    return kernel_info_.GetOperatorDomain();
+  }
+
+ private:
+  const Ort::ConstKernelInfo kernel_info_;
+};
+
+}  // namespace adapter
+}  // namespace ep
+}  // namespace onnxruntime

include/onnxruntime/ep/adapter/kernel_def_builder.h

@@ -0,0 +1,143 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#if !defined(ORT_EP_API_ADAPTER_HEADER_INCLUDED)
+#error "This header should not be included directly. Include ep/adapters.h instead."
+#endif
+
+#include <memory>
+
+#include "core/framework/data_types.h"
+
+namespace onnxruntime {
+namespace ep {
+namespace adapter {
+
+/// <summary>
+/// Gets an OrtMLDataType for a tensor type. Throws on error.
+/// </summary>
+/// <param name="elem_type"></param>
+/// <returns></returns>
+inline const OrtDataType* GetTensorType(ONNXTensorElementDataType elem_type) {
+  const OrtEpApi& ep_api = Ort::GetEpApi();
+  const OrtDataType* result = nullptr;
+
+  Ort::ThrowOnError(ep_api.GetTensorDataType(elem_type, &result));
+  return result;
+}
+
+inline const OrtDataType* MLDataTypeToOrtDataType(MLDataType ml_type) {
+  auto tensor_type = ml_type->AsTensorType();
+  EP_ENFORCE(tensor_type != nullptr, "EP Kernel registration only supports tensor types.");
+  auto elem_type = tensor_type->GetElementType();
+  auto primitive_type = static_cast<const PrimitiveDataTypeBase*>(elem_type);
+  auto onnx_type = static_cast<ONNXTensorElementDataType>(primitive_type->GetDataType());
+  return GetTensorType(onnx_type);
+}
+
+/// <summary>
+/// An adapter class partially implementing the interface of `onnxruntime::KernelDefBuilder`.
+/// </summary>
+struct KernelDefBuilder {
+  static std::unique_ptr<KernelDefBuilder> Create() { return std::make_unique<KernelDefBuilder>(); }
+
+  explicit KernelDefBuilder() {}
+
+  KernelDefBuilder& SetName(const char* op_name) {
+    builder_.SetOperatorType(op_name);
+    return *this;
+  }
+
+  KernelDefBuilder& SetDomain(const char* domain) {
+    builder_.SetDomain(domain);
+    return *this;
+  }
+
+  KernelDefBuilder& SinceVersion(int since_version) {
+    return SinceVersion(since_version, INT_MAX);
+  }
+
+  KernelDefBuilder& SinceVersion(int since_version_start, int since_version_end) {
+    builder_.SetSinceVersion(since_version_start, since_version_end);
+    return *this;
+  }
+
+  KernelDefBuilder& Provider(const char* provider_type) {
+    builder_.SetExecutionProvider(provider_type);
+    return *this;
+  }
+
+  KernelDefBuilder& TypeConstraint(const char* arg_name, std::vector<MLDataType> types) {
+    std::vector<const OrtDataType*> ort_types;
+    ort_types.reserve(types.size());
+    for (const auto& type : types) {
+      ort_types.push_back(MLDataTypeToOrtDataType(type));
+    }
+    builder_.AddTypeConstraint(arg_name, ort_types);
+    return *this;
+  }
+
+  KernelDefBuilder& TypeConstraint(const char* arg_name, MLDataType type) {
+    builder_.AddTypeConstraint(arg_name, MLDataTypeToOrtDataType(type));
+    return *this;
+  }
+
+  KernelDefBuilder& MayInplace(const std::vector<std::pair<int, int>>& inplaces) {
+    for (const auto& pair : inplaces) {
+      builder_.AddInputOutputMutableAlias(pair.first, pair.second);
+    }
+    return *this;
+  }
+  KernelDefBuilder& MayInplace(int input_index, int output_index) {
+    builder_.AddInputOutputMutableAlias(input_index, output_index);
+    return *this;
+  }
+
+  KernelDefBuilder& Alias(const std::vector<std::pair<int, int>>& aliases) {
+    for (const auto& pair : aliases) {
+      builder_.AddInputOutputAlias(pair.first, pair.second);
+    }
+    return *this;
+  }
+  KernelDefBuilder& Alias(int input_index, int output_index) {
+    builder_.AddInputOutputAlias(input_index, output_index);
+    return *this;
+  }
+
+  KernelDefBuilder& InputMemoryType(OrtMemType type, int input_index) {
+    builder_.SetInputMemType(input_index, type);
+    return *this;
+  }
+
+  KernelDefBuilder& InputMemoryType(OrtMemType type, const std::vector<int>& input_indexes) {
+    for (int input_index : input_indexes) {
+      builder_.SetInputMemType(input_index, type);
+    }
+    return *this;
+  }
+
+  KernelDefBuilder& OutputMemoryType(OrtMemType type, int output_index) {
+    builder_.SetOutputMemType(output_index, type);
+    return *this;
+  }
+
+  KernelDefBuilder& OutputMemoryType(OrtMemType type, const std::vector<int>& output_indexes) {
+    for (int output_index : output_indexes) {
+      builder_.SetOutputMemType(output_index, type);
+    }
+    return *this;
+  }
+
+  KernelDefBuilder& ExecQueueId(int /*queue_id*/) { return *this; }
+
+  Ort::KernelDef Build() { return builder_.Build(); }
+
+ private:
+  Ort::KernelDefBuilder builder_;
+};
+
+}  // namespace adapter
+}  // namespace ep
+}  // namespace onnxruntime