Make EPContext data callback APIs experimental

Convert the six EPContext read/write callback C APIs from stable APIs to experimental APIs using the mechanism introduced in PR #28746:

- OrtApi_SessionOptions_SetEpContextDataReadFunc
- OrtCompileApi_ModelCompilationOptions_SetEpContextDataWriteFunc
- OrtEpApi_SessionOptions_GetEpContextConfig
- OrtEpApi_ReleaseEpContextConfig
- OrtEpApi_EpContextConfig_GetEpContextDataReadFunc
- OrtEpApi_EpContextConfig_GetEpContextDataWriteFunc

Remove the C++ convenience wrappers and move the auxiliary types (OrtEpContextConfig, OrtReadNamedBufferFunc, OrtWriteNamedBufferFunc) into onnxruntime_experimental_c_api.h. Update the example plugin EP, sample helper utilities, and tests to use the generated experimental accessors.

Author: Gopalakrishnan Nallasamy

include/onnxruntime/core/session/onnxruntime_c_api.h

@@ -606,63 +606,6 @@ typedef OrtStatus*(ORT_API_CALL* OrtWriteBufferFunc)(_In_ void* state,
                                                      _In_ const void* buffer,
                                                      _In_ size_t buffer_num_bytes);
 
-/** \brief Function called to write named binary data.
- *
- * This callback is currently used for EPContext binary data, but its contract is intentionally generic so future APIs
- * can reuse it for other named data payloads. The callback is called synchronously by the component that receives it.
- * ORT does not own or retain buffer after the callback returns. ORT does not serialize invocations made by different
- * EP instances or worker threads.
- *
- * Each callback invocation represents one complete write operation for name. The callback signature does not
- * provide an offset, sequence number, or final-chunk marker, so the component invoking the callback must define any
- * chunked ordering and completion contract with the application. Current EPContext use should prefer a single callback
- * invocation per EPContext binary unless chunking semantics are documented by the EP.
- *
- * The application's implementation can process the data in any way (e.g., encrypt and store, upload to cloud storage,
- * or compress) before persisting it.
- *
- * \param[in] state Opaque pointer holding the user's state. ORT does not own or manage this pointer. The application
- *                  must keep it valid for the duration required by the API that accepted the callback and must provide
- *                  any synchronization required if it can be used concurrently.
- * \param[in] name The file name or logical data identifier as a null-terminated UTF-8 string.
- * \param[in] buffer The buffer containing data to write.
- * \param[in] buffer_num_bytes The size of the buffer in bytes.
- *
- * \return OrtStatus* Write status. Return nullptr on success.
- *                    Use CreateStatus to provide error info with ORT_FAIL as the error code.
- *                    ORT will release the OrtStatus* if not null.
- */
-typedef OrtStatus*(ORT_API_CALL* OrtWriteNamedBufferFunc)(_In_ void* state,
-                                                          _In_ const char* name,
-                                                          _In_ const void* buffer,
-                                                          _In_ size_t buffer_num_bytes);
-
-/** \brief Function called to read named binary data.
- *
- * This callback is currently used for EPContext binary data, but its contract is intentionally generic so future APIs
- * can reuse it for other named data payloads. The application reads, processes (e.g., decrypts, decompresses,
- * downloads), and returns the requested data. ORT provides an allocator so the application can allocate the output
- * buffer directly. The callback is called synchronously by the component that receives it. ORT does not serialize
- * invocations made by different EP instances or worker threads.
- *
- * \param[in] state Opaque pointer holding the user's state. ORT does not own or manage this pointer. The application
- *                  must keep it valid for the duration required by the API that accepted the callback and must provide
- *                  any synchronization required if it can be used concurrently.
- * \param[in] name The file name or logical data identifier to read as a null-terminated UTF-8 string.
- * \param[in] allocator ORT-provided allocator. The application must use this to allocate the output buffer.
- * \param[out] buffer Set by the implementation to the allocated buffer containing the output data.
- * \param[out] data_size Set by the implementation to the size of the output data in bytes.
- *
- * \return OrtStatus* Read status. Return nullptr on success.
- *                    Use CreateStatus to provide error info with ORT_FAIL as the error code.
- *                    ORT will release the OrtStatus* if not null.
- */
-typedef OrtStatus*(ORT_API_CALL* OrtReadNamedBufferFunc)(_In_ void* state,
-                                                         _In_ const char* name,
-                                                         _In_ OrtAllocator* allocator,
-                                                         _Outptr_ void** buffer,
-                                                         _Out_ size_t* data_size);
-
 /** \brief Function called by ORT to allow user to specify how an initializer should be saved, that is, either
  * written to an external file or stored within the model. ORT calls this function for every initializer when
  * generating a model.
@@ -7594,30 +7537,6 @@ struct OrtApi {
    * \since Version 1.28.
    */
   ORT_API_T(OrtExperimentalFnPtr, GetExperimentalFunction, _In_ const char* name);
-
-  /** \brief Registers a callback to provide EPContext binary data during session load.
-   *
-   * When loading a compiled model with external (non-embedded) EPContext binary data, an execution provider can
-   * retrieve this callback from OrtEpContextConfig and call it instead of reading the binary data from disk.
-   *
-   * Reading happens at session load, so this callback is configured on OrtSessionOptions. The corresponding write
-   * callback runs only at compile time and is configured on OrtModelCompilationOptions via
-   * OrtCompileApi::ModelCompilationOptions_SetEpContextDataWriteFunc.
-   *
-   * The state pointer is stored as-is and is not owned by ORT. It must remain valid while any session or EP created
-   * from these options may call the callback. If the same state may be used by multiple EPs or threads, the application
-   * is responsible for synchronization.
-   *
-   * \param[in] options The OrtSessionOptions instance.
-   * \param[in] read_func The OrtReadNamedBufferFunc callback.
-   * \param[in] state Opaque state passed to read_func. Can be NULL.
-   *
-   * \snippet{doc} snippets.dox OrtStatus Return Value
-   *
-   * \since Version 1.28.
-   */
-  ORT_API2_STATUS(SessionOptions_SetEpContextDataReadFunc, _Inout_ OrtSessionOptions* options,
-                  _In_ OrtReadNamedBufferFunc read_func, _In_opt_ void* state);
 };
 
 /*
@@ -8460,31 +8379,6 @@ struct OrtCompileApi {
   ORT_API2_STATUS(ModelCompilationOptions_SetInputModel,
                   _In_ OrtModelCompilationOptions* model_compile_options,
                   _In_ const OrtModel* model);
-
-  /** \brief Sets a callback for writing EPContext binary data during compilation.
-   *
-   * When EPContext embed mode is disabled, execution providers can retrieve this callback from OrtEpContextConfig and
-   * call it instead of writing EPContext binary data directly to disk.
-   *
-   * Writing happens only at compile time, so this callback is configured on OrtModelCompilationOptions. The
-   * corresponding read callback runs at session load and is configured on OrtSessionOptions via
-   * OrtApi::SessionOptions_SetEpContextDataReadFunc.
-   *
-   * The state pointer is stored as-is and is not owned by ORT. It must remain valid for the duration of the compile
-   * operation that may call the callback. If the same state may be used by multiple EPs or threads, the application is
-   * responsible for synchronization.
-   *
-   * \param[in] model_compile_options The OrtModelCompilationOptions instance.
-   * \param[in] write_func The OrtWriteNamedBufferFunc callback used to write EPContext bytes.
-   * \param[in] state Opaque state passed to write_func. Can be NULL.
-   *
-   * \snippet{doc} snippets.dox OrtStatus Return Value
-   *
-   * \since Version 1.28.
-   */
-  ORT_API2_STATUS(ModelCompilationOptions_SetEpContextDataWriteFunc,
-                  _In_ OrtModelCompilationOptions* model_compile_options,
-                  _In_ OrtWriteNamedBufferFunc write_func, _In_opt_ void* state);
 };
 
 /**

include/onnxruntime/core/session/onnxruntime_cxx_api.h

@@ -672,7 +672,6 @@ ORT_DEFINE_RELEASE(Value);
 ORT_DEFINE_RELEASE(ValueInfo);
 
 ORT_DEFINE_RELEASE_FROM_API_STRUCT(ModelCompilationOptions, GetCompileApi);
-ORT_DEFINE_RELEASE_FROM_API_STRUCT(EpContextConfig, GetEpApi);
 ORT_DEFINE_RELEASE_FROM_API_STRUCT(EpDevice, GetEpApi);
 ORT_DEFINE_RELEASE_FROM_API_STRUCT(KernelDef, GetEpApi);
 ORT_DEFINE_RELEASE_FROM_API_STRUCT(KernelDefBuilder, GetEpApi);
@@ -804,7 +803,6 @@ struct AllocatedFree {
 
 struct AllocatorWithDefaultOptions;
 struct Env;
-struct EpContextConfig;
 struct EpDevice;
 struct ExternalInitializerInfo;
 struct Graph;
@@ -1207,21 +1205,6 @@ struct EpDevice : detail::EpDeviceImpl<OrtEpDevice> {
            ConstKeyValuePairs ep_metadata = {}, ConstKeyValuePairs ep_options = {});
 };
 
-/** \brief Owning wrapper around ::OrtEpContextConfig. */
-struct EpContextConfig : detail::Base<OrtEpContextConfig> {
-  explicit EpContextConfig(std::nullptr_t) {}                                       ///< No instance is created
-  explicit EpContextConfig(OrtEpContextConfig* p) : Base<OrtEpContextConfig>{p} {}  ///< Take ownership
-
-  /// \brief Wraps OrtEpApi::SessionOptions_GetEpContextConfig
-  explicit EpContextConfig(const OrtSessionOptions* session_options);
-
-  /// \brief Wraps OrtEpApi::EpContextConfig_GetEpContextDataReadFunc
-  std::pair<OrtReadNamedBufferFunc, void*> GetEpContextDataReadFunc() const;
-
-  /// \brief Wraps OrtEpApi::EpContextConfig_GetEpContextDataWriteFunc
-  std::pair<OrtWriteNamedBufferFunc, void*> GetEpContextDataWriteFunc() const;
-};
-
 /** \brief Validate a compiled model's compatibility for one or more EP devices.
  *
  * Throws on error. Returns the resulting compatibility status.
@@ -1705,8 +1688,6 @@ struct SessionOptionsImpl : ConstSessionOptionsImpl<T> {
                                                                const std::vector<char*>& external_initializer_file_buffer_array,
                                                                const std::vector<size_t>& external_initializer_file_lengths);  ///< Wraps OrtApi::AddExternalInitializersFromFilesInMemory
 
-  SessionOptionsImpl& SetEpContextDataReadFunc(OrtReadNamedBufferFunc read_func, void* state);  ///< Wraps OrtApi::SessionOptions_SetEpContextDataReadFunc
-
   SessionOptionsImpl& AppendExecutionProvider_CPU(int use_arena);                                            ///< Wraps OrtApi::SessionOptionsAppendExecutionProvider_CPU
   SessionOptionsImpl& AppendExecutionProvider_CUDA(const OrtCUDAProviderOptions& provider_options);          ///< Wraps OrtApi::SessionOptionsAppendExecutionProvider_CUDA
   SessionOptionsImpl& AppendExecutionProvider_CUDA_V2(const OrtCUDAProviderOptionsV2& provider_options);     ///< Wraps OrtApi::SessionOptionsAppendExecutionProvider_CUDA_V2
@@ -1808,9 +1789,6 @@ struct ModelCompilationOptions : detail::Base<OrtModelCompilationOptions> {
   ///< Wraps OrtApi::ModelCompilationOptions_SetOutputModelWriteFunc
   ModelCompilationOptions& SetOutputModelWriteFunc(OrtWriteBufferFunc write_func, void* state);
 
-  ///< Wraps OrtCompileApi::ModelCompilationOptions_SetEpContextDataWriteFunc
-  ModelCompilationOptions& SetEpContextDataWriteFunc(OrtWriteNamedBufferFunc write_func, void* state);
-
   ModelCompilationOptions& SetEpContextBinaryInformation(const ORTCHAR_T* output_directory,
                                                          const ORTCHAR_T* model_name);  ///< Wraps OrtApi::ModelCompilationOptions_SetEpContextBinaryInformation
   ModelCompilationOptions& SetFlags(uint32_t flags);                                    ///< Wraps OrtApi::ModelCompilationOptions_SetFlags

include/onnxruntime/core/session/onnxruntime_cxx_inline.h

@@ -769,24 +769,6 @@ inline EpDevice::EpDevice(OrtEpFactory& ep_factory, ConstHardwareDevice& hardwar
   ThrowOnError(GetEpApi().CreateEpDevice(&ep_factory, hardware_device, ep_metadata, ep_options, &p_));
 }
 
-inline EpContextConfig::EpContextConfig(const OrtSessionOptions* session_options) {
-  ThrowOnError(GetEpApi().SessionOptions_GetEpContextConfig(session_options, &p_));
-}
-
-inline std::pair<OrtReadNamedBufferFunc, void*> EpContextConfig::GetEpContextDataReadFunc() const {
-  OrtReadNamedBufferFunc read_func = nullptr;
-  void* state = nullptr;
-  ThrowOnError(GetEpApi().EpContextConfig_GetEpContextDataReadFunc(this->p_, &read_func, &state));
-  return {read_func, state};
-}
-
-inline std::pair<OrtWriteNamedBufferFunc, void*> EpContextConfig::GetEpContextDataWriteFunc() const {
-  OrtWriteNamedBufferFunc write_func = nullptr;
-  void* state = nullptr;
-  ThrowOnError(GetEpApi().EpContextConfig_GetEpContextDataWriteFunc(this->p_, &write_func, &state));
-  return {write_func, state};
-}
-
 namespace detail {
 template <typename T>
 inline std::string EpAssignedSubgraphImpl<T>::GetEpName() const {
@@ -1353,12 +1335,6 @@ inline ModelCompilationOptions& ModelCompilationOptions::SetOutputModelWriteFunc
   return *this;
 }
 
-inline ModelCompilationOptions& ModelCompilationOptions::SetEpContextDataWriteFunc(
-    OrtWriteNamedBufferFunc write_func, void* state) {
-  Ort::ThrowOnError(GetCompileApi().ModelCompilationOptions_SetEpContextDataWriteFunc(this->p_, write_func, state));
-  return *this;
-}
-
 inline ModelCompilationOptions& ModelCompilationOptions::SetEpContextEmbedMode(
     bool embed_ep_context_in_model) {
   Ort::ThrowOnError(GetCompileApi().ModelCompilationOptions_SetEpContextEmbedMode(
@@ -1702,13 +1678,6 @@ inline SessionOptionsImpl<T>& SessionOptionsImpl<T>::AddExternalInitializersFrom
   return *this;
 }
 
-template <typename T>
-inline SessionOptionsImpl<T>& SessionOptionsImpl<T>::SetEpContextDataReadFunc(OrtReadNamedBufferFunc read_func,
-                                                                              void* state) {
-  ThrowOnError(GetApi().SessionOptions_SetEpContextDataReadFunc(this->p_, read_func, state));
-  return *this;
-}
-
 template <typename T>
 inline SessionOptionsImpl<T>& SessionOptionsImpl<T>::AppendExecutionProvider_CPU(int use_arena) {
   ThrowOnError(OrtSessionOptionsAppendExecutionProvider_CPU(this->p_, use_arena));

include/onnxruntime/core/session/onnxruntime_ep_c_api.h

@@ -18,7 +18,6 @@ extern "C" {
  * @{
  */
 ORT_RUNTIME_CLASS(Ep);
-ORT_RUNTIME_CLASS(EpContextConfig);
 ORT_RUNTIME_CLASS(EpFactory);
 ORT_RUNTIME_CLASS(EpGraphSupportInfo);
 ORT_RUNTIME_CLASS(MemoryDevice);  // opaque class to wrap onnxruntime::OrtDevice
@@ -2078,75 +2077,6 @@ struct OrtEpApi {
   ORT_API2_STATUS(ProfilingEventsContainer_AddEvents, _In_ OrtProfilingEventsContainer* events_container,
                   _In_reads_(num_events) const OrtProfilingEvent* const* events,
                   _In_ size_t num_events);
-
-  /** \brief Get the EPContext configuration from session options.
-   *
-   * Extracts EPContext-related data I/O callbacks from the session options into an opaque OrtEpContextConfig handle.
-   * The EP should call this during CreateEp() while session_options is still valid, and store the returned handle for
-   * use during Compile(). The returned config is always non-NULL and must be released with ReleaseEpContextConfig.
-   *
-   * The returned handle owns only ORT's copy of callback function pointers and opaque state pointer values. It does not
-   * own the application-provided state. The application is responsible for keeping callback state valid and
-   * synchronized while an EP may call callbacks retrieved from this config.
-   *
-   * \param[in] session_options The OrtSessionOptions instance.
-   * \param[out] config The extracted OrtEpContextConfig.
-   *
-   * \snippet{doc} snippets.dox OrtStatus Return Value
-   *
-   * \since Version 1.28.
-   */
-  ORT_API2_STATUS(SessionOptions_GetEpContextConfig,
-                  _In_ const OrtSessionOptions* session_options,
-                  _Outptr_ OrtEpContextConfig** config);
-
-  /** \brief Release an OrtEpContextConfig instance.
-   *
-   * \param[in] input The OrtEpContextConfig instance to release. May be NULL.
-   *
-   * \since Version 1.28.
-   */
-  ORT_CLASS_RELEASE(EpContextConfig);
-
-  /** \brief Get the application-provided EPContext data read callback.
-   *
-   * Returns the OrtReadNamedBufferFunc and opaque state pointer registered via
-   * OrtApi::SessionOptions_SetEpContextDataReadFunc. If no callback was registered, *read_func and *state are set to
-   * NULL. The EP is responsible for calling the callback when present and for using its own normal read path when no
-   * callback is present.
-   *
-   * \param[in] config The OrtEpContextConfig from SessionOptions_GetEpContextConfig.
-   * \param[out] read_func The registered read callback, or NULL if none was registered.
-   * \param[out] state Opaque state pointer passed to read_func, or NULL if none was registered.
-   *
-   * \snippet{doc} snippets.dox OrtStatus Return Value
-   *
-   * \since Version 1.28.
-   */
-  ORT_API2_STATUS(EpContextConfig_GetEpContextDataReadFunc,
-                  _In_ const OrtEpContextConfig* config,
-                  _Out_ OrtReadNamedBufferFunc* read_func,
-                  _Out_ void** state);
-
-  /** \brief Get the application-provided EPContext data write callback.
-   *
-   * Returns the OrtWriteNamedBufferFunc and opaque state pointer registered via
-   * OrtCompileApi::ModelCompilationOptions_SetEpContextDataWriteFunc. If no callback was registered, *write_func and
-   * *state are set to NULL. The EP is responsible for calling the callback when present and for using its own normal
-   * write path when no callback is present.
-   *
-   * \param[in] config The OrtEpContextConfig from SessionOptions_GetEpContextConfig.
-   * \param[out] write_func The registered write callback, or NULL if none was registered.
-   * \param[out] state Opaque state pointer passed to write_func, or NULL if none was registered.
-   *
-   * \snippet{doc} snippets.dox OrtStatus Return Value
-   *
-   * \since Version 1.28.
-   */
-  ORT_API2_STATUS(EpContextConfig_GetEpContextDataWriteFunc,
-                  _In_ const OrtEpContextConfig* config,
-                  _Out_ OrtWriteNamedBufferFunc* write_func,
-                  _Out_ void** state);
 };
 
 /**