Add webgpu plugin EP pipeline

cmake/onnxruntime_providers_webgpu.cmake

@@ -84,6 +84,14 @@
     add_definitions("-DONNX_NAMESPACE=onnx")
     add_definitions("-DONNX_USE_LITE_PROTO=1")
 
+    # Default plugin EP version to ORT_VERSION with "-dev" suffix if not explicitly provided.
+    if(NOT DEFINED onnxruntime_PLUGIN_EP_VERSION)
+      set(onnxruntime_PLUGIN_EP_VERSION "${ORT_VERSION}-dev")
+    endif()
+
+    # Set preprocessor definition for plugin EP version
+    target_compile_definitions(onnxruntime_providers_webgpu PRIVATE ORT_PLUGIN_EP_VERSION="${onnxruntime_PLUGIN_EP_VERSION}")
+
     # Set preprocessor definitions used in onnxruntime_providers_webgpu.rc
     if(WIN32)
       set(WEBGPU_DLL_FILE_DESCRIPTION "ONNX Runtime WebGPU Provider")

include/onnxruntime/ep/adapter/op_kernel.h

@@ -155,7 +155,11 @@ struct OpKernelContext {
   }
   bool GetUseDeterministicCompute() const {
     // TODO(fs-eire): Implement GetUseDeterministicCompute().
+    // if (CurrentOrtApiVersion() >= 25) {
+    //   return /* TBD: wait for GetUseDeterministicCompute to be added in ORT API v25 */;
+    // else {
     return false;
+    // }
   }
   void* GetGPUComputeStream() const {
     return context_.GetGPUComputeStream();

include/onnxruntime/ep/api.h

@@ -26,8 +26,37 @@
 
 namespace detail {
 inline std::optional<ApiPtrs> g_api_ptrs;
+
+inline bool TryGetAPIVersionFromVersionString(const char* version_str, uint32_t& api_version) {
+  // A valid version string should always be in the format of "1.{API_VERSION}.*".
+  if (!version_str || version_str[0] != '1' || version_str[1] != '.') {
+    return false;
+  }
+  const char* p = version_str + 2;
+  if (*p < '0' || *p > '9') {
+    return false;
+  }
+  uint32_t version = 0;
+  constexpr uint32_t kMaxBeforeMultiply = UINT32_MAX / 10;
+  while (*p >= '0' && *p <= '9') {
+    uint32_t digit = static_cast<uint32_t>(*p - '0');
+    if (version > kMaxBeforeMultiply || (version == kMaxBeforeMultiply && digit > UINT32_MAX % 10)) {
+      return false;
+    }
+    version = version * 10 + digit;
+    ++p;
+  }
+  if (*p != '.' && *p != '\0') {
+    return false;
+  }
+  api_version = version;
+  return true;
 }
 
+inline uint32_t g_current_ort_api_version{};
+
+}  // namespace detail
+
 /// <summary>
 /// Get the global instance of ApiPtrs.
 /// </summary>
@@ -45,16 +74,53 @@
 inline void ApiInit(const OrtApiBase* ort_api_base) {
   static std::once_flag init_flag;
   std::call_once(init_flag, [&]() {
-    // Manual init for the C++ API
-    const OrtApi* ort_api = ort_api_base->GetApi(ORT_API_VERSION);
+    // The following initialization process is composed of 3 steps:
+    // 1) Get the ORT API version string
+    // 2) Try to parse the ORT API version from the version string. If parsing fails, we assume the version is 24.
+    // 3) Get the ORT API for the parsed version and initialize the global API instance with it.
+    constexpr uint32_t ORT_BASE_API_VERSION = 24;
+    const char* version_str = ort_api_base->GetVersionString();
+    if (!version_str) {
+      version_str = "unknown";
+    }
+    uint32_t current_ort_version = 0;
+    if (!detail::TryGetAPIVersionFromVersionString(version_str, current_ort_version)) {
+      // If we fail to parse the version string, we can still try to get the API for the base version and hope it works.
+      current_ort_version = ORT_BASE_API_VERSION;
+    }
+    if (current_ort_version < ORT_BASE_API_VERSION) {
+      throw std::runtime_error("Failed to initialize EP API: the minimum required ORT API version is " + std::to_string(ORT_BASE_API_VERSION) +
+                               ", but the current version is \"" + version_str +
+                               "\" (parsed API version: " + std::to_string(current_ort_version) + ").");
+    }
+
+    const OrtApi* ort_api = ort_api_base->GetApi(current_ort_version);
+    if (!ort_api) {
+      throw std::runtime_error("Failed to initialize EP API: the current ORT version is \"" + std::string(version_str) +
+                               "\" but it does not support the parsed API version " + std::to_string(current_ort_version) + ".");
+    }
+
+    detail::g_current_ort_api_version = current_ort_version;
+
     const OrtEpApi* ep_api = ort_api->GetEpApi();
     const OrtModelEditorApi* model_editor_api = ort_api->GetModelEditorApi();
+
+    // Manual init for the C++ API
     Ort::InitApi(ort_api);
 
     // Initialize the global API instance
     detail::g_api_ptrs.emplace(*ort_api, *ep_api, *model_editor_api);
   });
 }
 
+/// <summary>
+/// Get the current ORT API version that the EP API has been initialized with.
+///
+/// This function should be called after ApiInit() to get the actual API version.
+/// </summary>
+inline uint32_t CurrentOrtApiVersion() {
+  return detail::g_current_ort_api_version;
+}
+
 }  // namespace ep
 }  // namespace onnxruntime

onnxruntime/core/providers/webgpu/ep/factory.cc

@@ -66,7 +66,7 @@ uint32_t ORT_API_CALL Factory::GetVendorIdImpl(const OrtEpFactory* /*this_ptr*/)
 }
 
 const char* ORT_API_CALL Factory::GetVersionImpl(const OrtEpFactory* /*this_ptr*/) noexcept {
-  return "0.1.0";
+  return ORT_PLUGIN_EP_VERSION;
 }
 
 OrtStatus* ORT_API_CALL Factory::GetSupportedDevicesImpl(

onnxruntime/core/session/onnxruntime_c_api.cc

@@ -55,6 +55,7 @@
 #include "core/session/onnxruntime_session_options_config_keys.h"
 #include "core/session/ort_apis.h"
 #include "core/session/ort_env.h"
+#include "core/session/ort_version_check.h"
 #include "core/session/utils.h"
 
 #if defined(USE_CUDA) || defined(USE_CUDA_PROVIDER_INTERFACE)
@@ -4830,6 +4831,9 @@ ORT_API(const OrtApi*, OrtApis::GetApi, uint32_t version) {
 }
 
 ORT_API(const char*, OrtApis::GetVersionString) {
+  static_assert(onnxruntime::version_check::IsOrtVersionValid(ORT_VERSION),
+                "ORT_VERSION must be in the format '1.Y.Z' where Y and Z are non-negative integers without leading "
+                "zeros, and Y must equal ORT_API_VERSION");
   return ORT_VERSION;
 }
 

onnxruntime/core/session/ort_version_check.h

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+#include "core/session/onnxruntime_c_api.h"
+
+namespace onnxruntime::version_check {
+
+// Parse a non-negative integer from a string_view without leading zeros.
+// Returns std::nullopt on failure (empty, leading zero, non-digit, or overflow).
+consteval std::optional<uint32_t> ParseUint(std::string_view str) {
+  if (str.empty()) return std::nullopt;
+  // Leading zeros are not allowed (except "0" itself).
+  if (str.size() > 1 && str[0] == '0') return std::nullopt;
+  uint64_t result = 0;
+  for (char c : str) {
+    if (c < '0' || c > '9') return std::nullopt;
+    result = result * 10 + static_cast<uint64_t>(c - '0');
+    if (result > UINT32_MAX) return std::nullopt;
+  }
+  return static_cast<uint32_t>(result);
+}
+
+// Validates a version string at compile time.
+// It must be in the format "1.Y.Z" where:
+//   - Major version is 1
+//   - Y and Z are non-negative integers without leading zeros
+//   - Y (minor version) must equal expected_api_version (defaults to ORT_API_VERSION)
+consteval bool IsOrtVersionValid(std::string_view version, uint32_t expected_api_version = ORT_API_VERSION) {
+  size_t first_dot = version.find('.');
+  if (first_dot == std::string_view::npos) return false;
+  size_t second_dot = version.find('.', first_dot + 1);
+  if (second_dot == std::string_view::npos) return false;
+  if (version.find('.', second_dot + 1) != std::string_view::npos) return false;  // Exactly two dots
+  std::string_view major = version.substr(0, first_dot);
+  std::string_view minor = version.substr(first_dot + 1, second_dot - first_dot - 1);
+  std::string_view patch = version.substr(second_dot + 1);
+  if (major != "1") {
+    return false;
+  }
+  auto minor_val = ParseUint(minor);
+  auto patch_val = ParseUint(patch);
+  if (!minor_val || !patch_val) {
+    return false;
+  }
+  if (*minor_val != expected_api_version) {
+    return false;
+  }
+  return true;
+}
+
+}  // namespace onnxruntime::version_check

onnxruntime/test/shared_lib/test_version.cc

@@ -1,31 +1,64 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+#include "onnxruntime_config.h"
 #include "core/session/onnxruntime_cxx_api.h"
+#include "core/session/ort_version_check.h"
 
-#include <cstdint>
-#include <charconv>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "absl/strings/str_split.h"
 #include "gtest/gtest.h"
 
-TEST(CApiTest, VersionConsistencyWithApiVersion) {
-  const auto version_string = Ort::GetVersionString();
-  const std::vector<std::string> version_string_components = absl::StrSplit(version_string, '.');
-  ASSERT_EQ(version_string_components.size(), size_t{3});
-
-  auto to_uint32_t = [](const std::string& s) -> std::optional<uint32_t> {
-    uint32_t result{};
-    if (std::from_chars(s.data(), s.data() + s.size(), result).ec == std::errc{}) {
-      return result;
-    }
-    return std::nullopt;
-  };
-
-  ASSERT_NE(to_uint32_t(version_string_components[0]), std::nullopt);
-  ASSERT_EQ(to_uint32_t(version_string_components[1]), uint32_t{ORT_API_VERSION});
-  ASSERT_NE(to_uint32_t(version_string_components[0]), std::nullopt);
+using onnxruntime::version_check::IsOrtVersionValid;
+using onnxruntime::version_check::ParseUint;
+
+// Compile-time tests for ParseUint
+static_assert(ParseUint("0") == 0u);
+static_assert(ParseUint("1") == 1u);
+static_assert(ParseUint("25") == 25u);
+static_assert(ParseUint("123") == 123u);
+static_assert(ParseUint("4294967295") == 4294967295u);   // UINT32_MAX
+static_assert(ParseUint("4294967296") == std::nullopt);  // UINT32_MAX + 1 overflows
+static_assert(ParseUint("") == std::nullopt);            // empty
+static_assert(ParseUint("01") == std::nullopt);          // leading zero
+static_assert(ParseUint("00") == std::nullopt);          // leading zero
+static_assert(ParseUint("abc") == std::nullopt);         // non-digit
+static_assert(ParseUint("1a") == std::nullopt);          // trailing non-digit
+static_assert(ParseUint("-1") == std::nullopt);          // negative sign
+static_assert(ParseUint("1.0") == std::nullopt);         // contains dot
+static_assert(ParseUint("0").has_value());
+static_assert(!ParseUint("").has_value());
+
+// Compile-time tests for IsOrtVersionValid (default expected_api_version = ORT_API_VERSION)
+static_assert(IsOrtVersionValid(ORT_VERSION));  // current version must be valid
+
+// Invalid formats
+static_assert(!IsOrtVersionValid(""));
+static_assert(!IsOrtVersionValid("1"));
+static_assert(!IsOrtVersionValid("1.0"));
+static_assert(!IsOrtVersionValid("1.0.0.0"));  // too many dots
+static_assert(!IsOrtVersionValid("2.0.0"));    // major != 1
+static_assert(!IsOrtVersionValid("1.02.0"));   // leading zero in minor
+static_assert(!IsOrtVersionValid("1.0.01"));   // leading zero in patch
+static_assert(!IsOrtVersionValid("1..0"));     // empty minor
+static_assert(!IsOrtVersionValid("1.0."));     // empty patch
+static_assert(!IsOrtVersionValid(".1.0"));     // empty major
+static_assert(!IsOrtVersionValid("abc"));      // non-numeric
+static_assert(!IsOrtVersionValid("1.abc.0"));  // non-numeric minor
+static_assert(!IsOrtVersionValid("1.0.abc"));  // non-numeric patch
+
+// Compile-time tests for IsOrtVersionValid with explicit expected_api_version
+static_assert(IsOrtVersionValid("1.0.0", 0));
+static_assert(IsOrtVersionValid("1.1.0", 1));
+static_assert(IsOrtVersionValid("1.25.0", 25));
+static_assert(IsOrtVersionValid("1.25.3", 25));
+static_assert(IsOrtVersionValid("1.100.0", 100));
+static_assert(!IsOrtVersionValid("1.25.0", 24));  // minor doesn't match expected
+static_assert(!IsOrtVersionValid("1.25.0", 26));  // minor doesn't match expected
+static_assert(!IsOrtVersionValid("1.0.0", 1));    // minor 0 != expected 1
+static_assert(!IsOrtVersionValid("2.0.0", 0));    // major != 1
+static_assert(!IsOrtVersionValid("1.02.0", 2));   // leading zero in minor
+static_assert(!IsOrtVersionValid("1.0.01", 0));   // leading zero in patch
+
+TEST(CApiTest, VersionIsValid) {
+  // Runtime sanity check — the version string returned by the API is the expected one.
+  EXPECT_STREQ(Ort::GetVersionString(), ORT_VERSION);
 }