onnxruntime_ep_c_api.h

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
 
// Do not include this file directly. Please include "onnxruntime_c_api.h" instead.
 
#if defined(__DOXYGEN__)
// When running a Doxygen build, include onnxruntime_c_api.h. Doxygen expects header files to be self-contained.
#include "onnxruntime_c_api.h"
#else
// In normal usage, do not include onnxruntime_c_api.h. This file is explicitly included in onnxruntime_c_api.h.
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
ORT_RUNTIME_CLASS(Ep);
ORT_RUNTIME_CLASS(EpFactory);
ORT_RUNTIME_CLASS(EpGraphSupportInfo);
ORT_RUNTIME_CLASS(MemoryDevice);  // opaque class to wrap onnxruntime::OrtDevice
ORT_RUNTIME_CLASS(NodeComputeContext);
 
ORT_RUNTIME_CLASS(DataTransferImpl);
ORT_RUNTIME_CLASS(SyncNotificationImpl);
ORT_RUNTIME_CLASS(SyncStreamImpl);
 
ORT_RUNTIME_CLASS(ExternalResourceImporterImpl);
 
struct OrtExternalMemoryHandle {
  uint32_t version;                        
  const OrtEpDevice* ep_device;            
  OrtExternalMemoryDescriptor descriptor;  
 
  void(ORT_API_CALL* Release)(_In_ OrtExternalMemoryHandle* handle);
};
 
struct OrtExternalSemaphoreHandle {
  uint32_t version;                           
  const OrtEpDevice* ep_device;               
  OrtExternalSemaphoreDescriptor descriptor;  
 
  void(ORT_API_CALL* Release)(_In_ OrtExternalSemaphoreHandle* handle);
};
 
// Opaque types for kernel-based EPs
ORT_RUNTIME_CLASS(KernelRegistry);
ORT_RUNTIME_CLASS(KernelDefBuilder);
ORT_RUNTIME_CLASS(KernelDef);
ORT_RUNTIME_CLASS(DataType);  // combination of ONNXType (e.g., Tensor, Map, Sequence) and ONNXTensorElementDataType
ORT_RUNTIME_CLASS(SharedPrePackedWeightCache);
 
struct OrtDataTransferImpl {
  uint32_t ort_version_supported;  
 
  ORT_API_T(void, Release, _In_ OrtDataTransferImpl* this_ptr);
 
  ORT_API_T(bool, CanCopy, _In_ const OrtDataTransferImpl* this_ptr,
            _In_ const OrtMemoryDevice* src_memory_device, _In_ const OrtMemoryDevice* dst_memory_device);
 
  ORT_API2_STATUS(CopyTensors, _In_ OrtDataTransferImpl* this_ptr,
                  _In_reads_(num_tensors) const OrtValue** src_tensors,
                  _In_reads_(num_tensors) OrtValue** dst_tensors,
                  _In_reads_(num_tensors) OrtSyncStream** streams,
                  _In_ size_t num_tensors);
};
 
struct OrtSyncNotificationImpl {
  uint32_t ort_version_supported;  
 
  ORT_API_T(void, Release, _In_ OrtSyncNotificationImpl* this_ptr);
 
  ORT_API2_STATUS(Activate, _In_ OrtSyncNotificationImpl* this_ptr);
 
  ORT_API2_STATUS(WaitOnDevice, _In_ OrtSyncNotificationImpl* this_ptr, _In_ OrtSyncStream* consumer_stream);
 
  ORT_API2_STATUS(WaitOnHost, _In_ OrtSyncNotificationImpl* this_ptr);
};
 
struct OrtSyncStreamImpl {
  uint32_t ort_version_supported;  
 
  ORT_API_T(void, Release, _In_ OrtSyncStreamImpl* this_ptr);
 
  ORT_API_T(void*, GetHandle, _In_ OrtSyncStreamImpl* this_ptr);
 
  ORT_API2_STATUS(CreateNotification, _In_ OrtSyncStreamImpl* this_ptr,
                  _Outptr_ OrtSyncNotificationImpl** notification);
 
  ORT_API2_STATUS(Flush, _In_ OrtSyncStreamImpl* this_ptr);
 
  ORT_API2_STATUS(OnSessionRunEnd, _In_ OrtSyncStreamImpl* this_ptr);
};
 
struct OrtExternalResourceImporterImpl {
  uint32_t ort_version_supported;  
 
  // Memory operations (stream-independent)
 
  ORT_API_T(bool, CanImportMemory,
            _In_ const OrtExternalResourceImporterImpl* this_ptr,
            _In_ OrtExternalMemoryHandleType handle_type);
 
  ORT_API2_STATUS(ImportMemory,
                  _In_ OrtExternalResourceImporterImpl* this_ptr,
                  _In_ const OrtExternalMemoryDescriptor* desc,
                  _Outptr_ OrtExternalMemoryHandle** out_handle);
 
  ORT_API_T(void, ReleaseMemory,
            _In_ OrtExternalResourceImporterImpl* this_ptr,
            _In_ OrtExternalMemoryHandle* handle);
 
  ORT_API2_STATUS(CreateTensorFromMemory,
                  _In_ OrtExternalResourceImporterImpl* this_ptr,
                  _In_ const OrtExternalMemoryHandle* mem_handle,
                  _In_ const OrtExternalTensorDescriptor* tensor_desc,
                  _Outptr_ OrtValue** out_tensor);
 
  // Semaphore operations (require stream)
 
  ORT_API_T(bool, CanImportSemaphore,
            _In_ const OrtExternalResourceImporterImpl* this_ptr,
            _In_ OrtExternalSemaphoreType type);
 
  ORT_API2_STATUS(ImportSemaphore,
                  _In_ OrtExternalResourceImporterImpl* this_ptr,
                  _In_ const OrtExternalSemaphoreDescriptor* desc,
                  _Outptr_ OrtExternalSemaphoreHandle** out_handle);
 
  ORT_API_T(void, ReleaseSemaphore,
            _In_ OrtExternalResourceImporterImpl* this_ptr,
            _In_ OrtExternalSemaphoreHandle* handle);
 
  ORT_API2_STATUS(WaitSemaphore,
                  _In_ OrtExternalResourceImporterImpl* this_ptr,
                  _In_ OrtExternalSemaphoreHandle* handle,
                  _In_ OrtSyncStream* stream,
                  _In_ uint64_t value);
 
  ORT_API2_STATUS(SignalSemaphore,
                  _In_ OrtExternalResourceImporterImpl* this_ptr,
                  _In_ OrtExternalSemaphoreHandle* handle,
                  _In_ OrtSyncStream* stream,
                  _In_ uint64_t value);
 
  // Release the capability object itself
 
  ORT_API_T(void, Release, _In_ OrtExternalResourceImporterImpl* this_ptr);
};
 
struct OrtNodeFusionOptions;
typedef struct OrtNodeFusionOptions OrtNodeFusionOptions;
 
struct OrtNodeComputeInfo;
typedef struct OrtNodeComputeInfo OrtNodeComputeInfo;
 
struct OrtNodeFusionOptions {
  uint32_t ort_version_supported;
 
  bool drop_constant_initializers;
 
  // const OrtNode* fused_node_schema;
};
 
struct OrtNodeComputeInfo {
  uint32_t ort_version_supported;
 
  OrtStatus*(ORT_API_CALL* CreateState)(_In_ OrtNodeComputeInfo* this_ptr,
                                        _In_ OrtNodeComputeContext* compute_context,
                                        _Outptr_ void** compute_state);
 
  OrtStatus*(ORT_API_CALL* Compute)(_In_ OrtNodeComputeInfo* this_ptr, _In_ void* compute_state,
                                    _In_ OrtKernelContext* kernel_context);
 
  void(ORT_API_CALL* ReleaseState)(_In_ OrtNodeComputeInfo* this_ptr, _Frees_ptr_opt_ void* compute_state);
};
 
struct OrtKernelImpl;
typedef struct OrtKernelImpl OrtKernelImpl;
 
struct OrtKernelImpl {
  uint32_t ort_version_supported;  
  uint32_t flags;                  
 
  ORT_API2_STATUS(Compute, _In_ OrtKernelImpl* this_ptr, _In_ OrtKernelContext* context);
 
  ORT_API_T(void, Release, _In_ OrtKernelImpl* this_ptr);
 
  ORT_API2_STATUS(PrePackWeight, _In_ OrtKernelImpl* this_ptr, _In_ const OrtValue* tensor,
                  _In_ int input_index, _Inout_ OrtAllocator* allocator,
                  _In_opt_ OrtSharedPrePackedWeightCache* prepacked_weight_cache, _Out_ bool* is_packed);
 
  ORT_API2_STATUS(SetSharedPrePackedWeight, _In_ OrtKernelImpl* this_ptr,
                  _In_reads_(num_buffers) const void* const* buffer_data_ptrs,
                  _In_reads_(num_buffers) const size_t* buffer_data_sizes,
                  _In_ size_t num_buffers, _In_ int input_index);
};
 
typedef OrtStatus*(ORT_API_CALL* OrtKernelCreateFunc)(_In_ void* kernel_create_func_state,
                                                      _In_ const OrtKernelInfo* info,
                                                      _Outptr_result_maybenull_ OrtKernelImpl** kernel_out);
 
struct OrtLoopKernelHelper;
typedef struct OrtLoopKernelHelper OrtLoopKernelHelper;
 
struct OrtLoopKernelHelper {
  uint32_t ort_version_supported;  
 
  ORT_API_T(void, Release, _In_ OrtLoopKernelHelper* this_ptr);
 
  ORT_API2_STATUS(ConcatOutput, _In_ OrtLoopKernelHelper* this_ptr, _In_opt_ void* stream_handle,
                  _In_reads_(num_per_iteration_outputs) const OrtValue* const* per_iteration_outputs,
                  _In_ size_t num_per_iteration_outputs, _Out_writes_bytes_all_(output_size_in_bytes) void* output,
                  _In_ size_t output_size_in_bytes);
};
 
struct OrtScanKernelHelper;
typedef struct OrtScanKernelHelper OrtScanKernelHelper;
 
struct OrtScanKernelHelper {
  uint32_t ort_version_supported;  
 
  ORT_API_T(void, Release, _In_ OrtScanKernelHelper* this_ptr);
 
  ORT_API2_STATUS(Transpose, _In_ OrtScanKernelHelper* this_ptr,
                  _In_reads_(num_permutation_elems) const size_t* permutation, _In_ size_t num_permutation_elems,
                  _In_ const OrtValue* input, _In_opt_ OrtSyncStream* stream, _Inout_ OrtValue* output);
};
 
struct OrtEpApi {
  ORT_API2_STATUS(CreateEpDevice, _In_ OrtEpFactory* ep_factory,
                  _In_ const OrtHardwareDevice* hardware_device,
                  _In_opt_ const OrtKeyValuePairs* ep_metadata,
                  _In_opt_ const OrtKeyValuePairs* ep_options,
                  _Out_ OrtEpDevice** ep_device);
 
  ORT_CLASS_RELEASE(EpDevice);
 
  ORT_API2_STATUS(EpGraphSupportInfo_AddNodesToFuse, _In_ OrtEpGraphSupportInfo* graph_support_info,
                  _In_reads_(num_nodes) const OrtNode* const* nodes, _In_ size_t num_nodes,
                  _In_opt_ const OrtNodeFusionOptions* node_fusion_options);
 
  ORT_API2_STATUS(EpGraphSupportInfo_AddSingleNode, _In_ OrtEpGraphSupportInfo* graph_support_info,
                  _In_ const OrtNode* node);
 
  ORT_API_T(const char*, NodeComputeContext_NodeName, _In_ const OrtNodeComputeContext* context);
 
  ORT_API2_STATUS(EpDevice_AddAllocatorInfo, _In_ OrtEpDevice* ep_device,
                  _In_ const OrtMemoryInfo* allocator_memory_info);
 
  ORT_API_T(const OrtMemoryDevice*, MemoryInfo_GetMemoryDevice, _In_ const OrtMemoryInfo* memory_info);
 
  ORT_API_T(const OrtMemoryDevice*, Value_GetMemoryDevice, _In_ const OrtValue* value);
 
  ORT_API_T(bool, MemoryDevice_AreEqual, _In_ const OrtMemoryDevice* a, _In_ const OrtMemoryDevice* b);
 
  ORT_API_T(OrtMemoryInfoDeviceType, MemoryDevice_GetDeviceType, _In_ const OrtMemoryDevice* memory_device);
 
  ORT_API_T(OrtDeviceMemoryType, MemoryDevice_GetMemoryType, _In_ const OrtMemoryDevice* memory_device);
 
  ORT_API_T(uint32_t, MemoryDevice_GetVendorId, _In_ const OrtMemoryDevice* memory_device);
 
  ORT_API_T(uint32_t, MemoryDevice_GetDeviceId, _In_ const OrtMemoryDevice* memory_device);
 
  ORT_API_T(const OrtSyncStreamImpl*, SyncStream_GetImpl, _In_ const OrtSyncStream* stream);
 
  ORT_API_T(uint64_t, SyncStream_GetSyncId, _In_ const OrtSyncStream* stream);
 
  ORT_API_T(uint64_t, GetSyncIdForLastWaitOnSyncStream,
            _In_ const OrtSyncStream* producer_stream, _In_ const OrtSyncStream* consumer_stream);
 
  ORT_API2_STATUS(CreateHardwareDevice, _In_ OrtHardwareDeviceType type,
                  _In_ uint32_t vendor_id,
                  _In_ uint32_t device_id,
                  _In_ const char* vendor_name,
                  _In_opt_ const OrtKeyValuePairs* metadata,
                  _Out_ OrtHardwareDevice** hardware_device);
 
  ORT_CLASS_RELEASE(HardwareDevice);
 
  ORT_API2_STATUS(CreateKernelRegistry, _Outptr_ OrtKernelRegistry** kernel_registry);
 
  ORT_CLASS_RELEASE(KernelRegistry);
 
  ORT_API2_STATUS(KernelRegistry_AddKernel, _In_ OrtKernelRegistry* kernel_registry,
                  _In_ const OrtKernelDef* kernel_def, _In_ OrtKernelCreateFunc kernel_create_func,
                  _In_ void* kernel_create_func_state);
 
  ORT_API2_STATUS(CreateKernelDefBuilder, _Outptr_ OrtKernelDefBuilder** kernel_def_builder_out);
 
  ORT_CLASS_RELEASE(KernelDefBuilder);
 
  ORT_API2_STATUS(KernelDefBuilder_SetOperatorType, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_ const char* op_type);
 
  ORT_API2_STATUS(KernelDefBuilder_SetDomain, _In_ OrtKernelDefBuilder* kernel_def_builder, _In_ const char* domain);
 
  ORT_API2_STATUS(KernelDefBuilder_SetSinceVersion, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_ int since_version_start, _In_ int since_version_end);
 
  ORT_API2_STATUS(KernelDefBuilder_SetExecutionProvider, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_ const char* ep_name);
 
  ORT_API2_STATUS(KernelDefBuilder_SetInputMemType, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_ size_t input_index, _In_ OrtMemType mem_type);
 
  ORT_API2_STATUS(KernelDefBuilder_SetOutputMemType, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_ size_t output_index, _In_ OrtMemType mem_type);
 
  ORT_API2_STATUS(KernelDefBuilder_AddTypeConstraint, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_ const char* arg_name, _In_reads_(num_types) const OrtDataType* const* types,
                  _In_ size_t num_types);
 
  ORT_API2_STATUS(KernelDefBuilder_AddInputOutputAliases, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_reads_(num_io_indices) int const* input_indices,
                  _In_reads_(num_io_indices) int const* output_indices,
                  _In_ size_t num_io_indices);
 
  ORT_API2_STATUS(KernelDefBuilder_AddInputOutputMutableAliases, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _In_reads_(num_io_indices) int const* input_indices,
                  _In_reads_(num_io_indices) int const* output_indices,
                  _In_ size_t num_io_indices);
 
  ORT_API2_STATUS(KernelDefBuilder_Build, _In_ OrtKernelDefBuilder* kernel_def_builder,
                  _Outptr_ OrtKernelDef** kernel_def_out);
 
  ORT_CLASS_RELEASE(KernelDef);
 
  ORT_API_T(const char*, KernelDef_GetOperatorType, _In_ const OrtKernelDef* kernel_def);
 
  ORT_API_T(const char*, KernelDef_GetDomain, _In_ const OrtKernelDef* kernel_def);
 
  ORT_API2_STATUS(KernelDef_GetSinceVersion, _In_ const OrtKernelDef* kernel_def,
                  _Out_ int* start_version, _Out_ int* end_version);
 
  ORT_API_T(const char*, KernelDef_GetExecutionProvider, _In_ const OrtKernelDef* kernel_def);
 
  ORT_API2_STATUS(KernelDef_GetInputMemType, _In_ const OrtKernelDef* kernel_def,
                  _In_ size_t input_index, _Out_ OrtMemType* mem_type);
 
  ORT_API2_STATUS(KernelDef_GetOutputMemType, _In_ const OrtKernelDef* kernel_def,
                  _In_ size_t output_index, _Out_ OrtMemType* mem_type);
 
  ORT_API2_STATUS(GetTensorDataType, _In_ ONNXTensorElementDataType elem_type,
                  _Outptr_ const OrtDataType** out);
 
  ORT_API2_STATUS(EpGraphSupportInfo_LookUpKernel, _In_ OrtEpGraphSupportInfo* graph_support_info,
                  _In_ const OrtNode* node, _Outptr_result_maybenull_ const OrtKernelDef** out_kernel_def);
 
  ORT_API2_STATUS(SharedPrePackedWeightCache_StoreWeightData,
                  _In_ OrtSharedPrePackedWeightCache* prepacked_weight_cache,
                  _In_reads_(num_buffers) void** buffer_data_ptrs, _In_reads_(num_buffers) size_t* buffer_data_sizes,
                  _In_ size_t num_buffers);
 
  ORT_API2_STATUS(KernelInfo_GetEp, _In_ const OrtKernelInfo* info, _Outptr_ const OrtEp** ep);
 
  ORT_API2_STATUS(DeviceEpIncompatibilityDetails_SetDetails, _Inout_ OrtDeviceEpIncompatibilityDetails* details,
                  _In_ uint32_t reasons_bitmask,
                  _In_ int32_t error_code,
                  _In_opt_z_ const char* notes);
 
  ORT_API2_STATUS(CreateIfKernel, _In_ const OrtKernelInfo* kernel_info, _Outptr_ OrtKernelImpl** kernel_out);
 
  ORT_API2_STATUS(CreateLoopKernel, _In_ const OrtKernelInfo* kernel_info, _In_ OrtLoopKernelHelper* helper,
                  _Outptr_ OrtKernelImpl** kernel_out);
 
  ORT_API2_STATUS(CreateScanKernel, _In_ const OrtKernelInfo* kernel_info, _In_ OrtScanKernelHelper* helper,
                  _Outptr_ OrtKernelImpl** kernel_out);
 
  ORT_CLASS_RELEASE(KernelImpl);
 
  ORT_API2_STATUS(GetEnvConfigEntries, _Outptr_ OrtKeyValuePairs** config_entries);
};
 
typedef enum OrtEpDataLayout {
  OrtEpDataLayout_NCHW = 0,
  OrtEpDataLayout_NHWC,
 
  OrtEpDataLayout_Default = OrtEpDataLayout_NCHW,
} OrtEpDataLayout;
 
struct OrtEp {
  uint32_t ort_version_supported;
 
  ORT_API_T(const char*, GetName, _In_ const OrtEp* this_ptr);
 
  ORT_API2_STATUS(GetCapability, _In_ OrtEp* this_ptr, _In_ const OrtGraph* graph,
                  _Inout_ OrtEpGraphSupportInfo* graph_support_info);
 
  ORT_API2_STATUS(Compile, _In_ OrtEp* this_ptr, _In_ const OrtGraph** graphs,
                  _In_ const OrtNode** fused_nodes, _In_ size_t count,
                  _Out_writes_all_(count) OrtNodeComputeInfo** node_compute_infos,
                  _Out_writes_(count) OrtNode** ep_context_nodes);
 
  ORT_API_T(void, ReleaseNodeComputeInfos, _In_ OrtEp* this_ptr,
            OrtNodeComputeInfo** node_compute_infos,
            _In_ size_t num_node_compute_infos);
 
  ORT_API2_STATUS(GetPreferredDataLayout, _In_ OrtEp* this_ptr, _Out_ OrtEpDataLayout* preferred_data_layout);
 
  ORT_API2_STATUS(ShouldConvertDataLayoutForOp, _In_ OrtEp* this_ptr,
                  _In_z_ const char* domain, _In_z_ const char* op_type,
                  _In_ OrtEpDataLayout target_data_layout,
                  _Outptr_ int* should_convert);
 
  ORT_API2_STATUS(SetDynamicOptions, _In_ OrtEp* this_ptr,
                  _In_reads_(num_options) const char* const* option_keys,
                  _In_reads_(num_options) const char* const* option_values,
                  _In_ size_t num_options);
 
  ORT_API2_STATUS(OnRunStart, _In_ OrtEp* this_ptr, _In_ const OrtRunOptions* run_options);
 
  ORT_API2_STATUS(OnRunEnd, _In_ OrtEp* this_ptr, _In_ const OrtRunOptions* run_options, _In_ bool sync_stream);
 
  ORT_API2_STATUS(CreateAllocator, _In_ OrtEp* this_ptr,
                  _In_ const OrtMemoryInfo* memory_info,
                  _Outptr_result_maybenull_ OrtAllocator** allocator);
 
  ORT_API2_STATUS(CreateSyncStreamForDevice, _In_ OrtEp* this_ptr,
                  _In_ const OrtMemoryDevice* memory_device,
                  _Outptr_ OrtSyncStreamImpl** stream);
 
  ORT_API_T(const char*, GetCompiledModelCompatibilityInfo, _In_ OrtEp* this_ptr,
            _In_ const OrtGraph* graph);
 
  ORT_API2_STATUS(GetKernelRegistry, _In_ OrtEp* this_ptr,
                  _Outptr_result_maybenull_ const OrtKernelRegistry** kernel_registry);
 
  ORT_API2_STATUS(IsConcurrentRunSupported, _In_ OrtEp* this_ptr, _Outptr_ bool* is_supported);
};
 
typedef OrtStatus* (*CreateEpApiFactoriesFn)(_In_ const char* registered_name, _In_ const OrtApiBase* ort_api_base,
                                             _In_ const OrtLogger* default_logger,
                                             _Inout_ OrtEpFactory** factories, _In_ size_t max_factories,
                                             _Out_ size_t* num_factories);
 
typedef OrtStatus* (*ReleaseEpApiFactoryFn)(_In_ OrtEpFactory* factory);
 
struct OrtEpFactory {
  uint32_t ort_version_supported;
 
  ORT_API_T(const char*, GetName, const OrtEpFactory* this_ptr);
 
  ORT_API_T(const char*, GetVendor, const OrtEpFactory* this_ptr);  // return EP vendor
 
  ORT_API2_STATUS(GetSupportedDevices, _In_ OrtEpFactory* this_ptr,
                  _In_reads_(num_devices) const OrtHardwareDevice* const* devices,
                  _In_ size_t num_devices,
                  _Inout_ OrtEpDevice** ep_devices,
                  _In_ size_t max_ep_devices,
                  _Out_ size_t* num_ep_devices);
 
  ORT_API2_STATUS(CreateEp, _In_ OrtEpFactory* this_ptr,
                  _In_reads_(num_devices) const OrtHardwareDevice* const* devices,
                  _In_reads_(num_devices) const OrtKeyValuePairs* const* ep_metadata_pairs,
                  _In_ size_t num_devices,
                  _In_ const OrtSessionOptions* session_options,
                  _In_ const OrtLogger* logger, _Outptr_ OrtEp** ep);
 
  ORT_API_T(void, ReleaseEp, OrtEpFactory* this_ptr, struct OrtEp* ep);
 
  ORT_API_T(uint32_t, GetVendorId, const OrtEpFactory* this_ptr);
 
  ORT_API_T(const char*, GetVersion, _In_ const OrtEpFactory* this_ptr);
 
  ORT_API2_STATUS(ValidateCompiledModelCompatibilityInfo, _In_ OrtEpFactory* this_ptr,
                  _In_reads_(num_devices) const OrtHardwareDevice* const* devices,
                  _In_ size_t num_devices,
                  _In_ const char* compatibility_info,
                  _Out_ OrtCompiledModelCompatibility* model_compatibility);
 
  ORT_API2_STATUS(CreateAllocator, _In_ OrtEpFactory* this_ptr,
                  _In_ const OrtMemoryInfo* memory_info,
                  _In_opt_ const OrtKeyValuePairs* allocator_options,
                  _Outptr_result_maybenull_ OrtAllocator** allocator);
 
  ORT_API_T(void, ReleaseAllocator, _In_ OrtEpFactory* this_ptr, _In_ OrtAllocator* allocator);
 
  ORT_API2_STATUS(CreateDataTransfer, _In_ OrtEpFactory* this_ptr,
                  _Outptr_result_maybenull_ OrtDataTransferImpl** data_transfer);
 
  ORT_API_T(bool, IsStreamAware, _In_ const OrtEpFactory* this_ptr);
 
  ORT_API2_STATUS(CreateSyncStreamForDevice, _In_ OrtEpFactory* this_ptr,
                  _In_ const OrtMemoryDevice* memory_device,
                  _In_opt_ const OrtKeyValuePairs* stream_options,
                  _Outptr_ OrtSyncStreamImpl** stream);
 
  ORT_API2_STATUS(GetHardwareDeviceIncompatibilityDetails, _In_ OrtEpFactory* this_ptr,
                  _In_ const OrtHardwareDevice* hw,
                  _Inout_ OrtDeviceEpIncompatibilityDetails* details);
 
  ORT_API2_STATUS(CreateExternalResourceImporterForDevice, _In_ OrtEpFactory* this_ptr,
                  _In_ const OrtEpDevice* ep_device,
                  _Outptr_result_maybenull_ OrtExternalResourceImporterImpl** out_importer);
 
  ORT_API2_STATUS(GetNumCustomOpDomains, _In_ OrtEpFactory* this_ptr, _Out_ size_t* num_domains);
 
  ORT_API2_STATUS(GetCustomOpDomains, _In_ OrtEpFactory* this_ptr,
                  _Out_writes_all_(num_domains) OrtCustomOpDomain** domains, _In_ size_t num_domains);
};
 
#ifdef __cplusplus
}
#endif