[OVEP] OpenVINO Development Updates

.github/workflows/windows_openvino.yml

@@ -51,12 +51,12 @@ jobs:
         with:
           architecture: x64
 
-      - name: Download OpenVINO Toolkit v2026.1.0
+      - name: Download OpenVINO Toolkit v2026.2.1
         env:
-          OpenVINOVersion: 2026.1.0
+          OpenVINOVersion: 2026.2.1
         shell: pwsh
         run: |
-          $Url ="https://storage.openvinotoolkit.org/repositories/openvino/packages/2026.1/windows_vc_mt/openvino_toolkit_windows_vc_mt_2026.1.0.21367.63e31528c62_x86_64.zip"
+          $Url ="https://storage.openvinotoolkit.org/repositories/openvino/packages/2026.2.1/windows_vc_mt/openvino_toolkit_windows_vc_mt_2026.2.1.21919.ede283a88e3_x86_64.zip"
           $OutputPath = "$env:RUNNER_TEMP\openvino.zip"
           $ExtractPath = "$env:RUNNER_TEMP\openvino-v$env:OpenVINOVersion"
           $TempExtractPath = "$env:RUNNER_TEMP\openvino_temp"
@@ -99,7 +99,7 @@ jobs:
         shell: pwsh
         # Use $GITHUB_ENV to set the variable for subsequent steps
         run: |
-          $openVinoRootDir = Join-Path $env:RUNNER_TEMP "openvino-v2026.1.0"
+          $openVinoRootDir = Join-Path $env:RUNNER_TEMP "openvino-v2026.2.1"
           echo "OpenVINORootDir=$openVinoRootDir" >> $env:GITHUB_ENV
 
       - name: Print OpenVINORootDir after downloading OpenVINO

cmake/onnxruntime_providers_openvino.cmake

@@ -13,8 +13,8 @@
 
   # Header paths
   find_package(OpenVINO REQUIRED COMPONENTS Runtime ONNX)
-  if(OpenVINO_VERSION VERSION_LESS 2025.0)
-    message(FATAL_ERROR "OpenVINO 2025.0 and newer are supported. Please, use latest OpenVINO release")
+  if(OpenVINO_VERSION VERSION_LESS 2026.0)
+    message(FATAL_ERROR "OpenVINO 2026.0 and newer are supported. Please, use latest OpenVINO release")
   endif()
 
   if(OpenVINO_VERSION VERSION_GREATER_EQUAL 2024.4)

onnxruntime/core/providers/openvino/onnx_ctx_model_helper.cc

@@ -1,6 +1,7 @@
 // Copyright (C) Intel Corporation
 // Licensed under the MIT License
 
+#include <cctype>
 #include <string>
 #include <fstream>
 #include <vector>
@@ -243,10 +244,18 @@ std::shared_ptr<SharedContext> EPCtxHandler::Initialize(const std::vector<IExecu
         shared_context->Deserialize(ss);
       }
     } else {
-      ORT_THROW_IF_ERROR(utils::ValidateExternalDataPath(session_context.GetOutputModelPath(),
-                                                         std::filesystem::path(ep_cache_context)));
-      std::filesystem::path ep_context_path = session_context.GetOutputModelPath().parent_path() / ep_cache_context;
-      if (ep_context_path.extension() != ".xml") {
+      const std::filesystem::path cache_context_path{ep_cache_context};
+      // Compare the extension case-insensitively so that ".XML", ".Xml", etc. are also treated as XML.
+      std::string extension = cache_context_path.extension().string();
+      std::transform(extension.begin(), extension.end(), extension.begin(),
+                     [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+      const bool is_xml = (extension == ".xml");
+      const std::filesystem::path& validation_base_path = is_xml
+                                                              ? session_context.GetModelPath()
+                                                              : session_context.GetOutputModelPath();
+      ORT_THROW_IF_ERROR(utils::ValidateExternalDataPath(validation_base_path, cache_context_path));
+      const std::filesystem::path ep_context_path = validation_base_path.parent_path() / cache_context_path;
+      if (!is_xml) {
         shared_context = shared_context_manager_->GetOrCreateSharedContext(ep_context_path);
         shared_context->Deserialize();
       }

onnxruntime/core/providers/openvino/ov_versions/capability.cc

@@ -41,16 +41,14 @@ GetCapability::GetCapability(const EPCtxHandler& ep_ctx_handler,
     npu_qdq_optimizer_enabled = true;  // see data_ops.cc ~615 where we check for int16 types for gpu, this may change to a better approach later
   }
 
-#if OPENVINO_VERSION_MAJOR == 2026 && OPENVINO_VERSION_MINOR == 1
+#if OPENVINO_VERSION_MAJOR == 2026 && OPENVINO_VERSION_MINOR == 2
+  data_ops_ = std::make_unique<DataOps>(graph_viewer_, V_2026_2, device_type_, npu_qdq_optimizer_enabled);
+#elif OPENVINO_VERSION_MAJOR == 2026 && OPENVINO_VERSION_MINOR == 1
   data_ops_ = std::make_unique<DataOps>(graph_viewer_, V_2026_1, device_type_, npu_qdq_optimizer_enabled);
 #elif OPENVINO_VERSION_MAJOR == 2026 && OPENVINO_VERSION_MINOR == 0
   data_ops_ = std::make_unique<DataOps>(graph_viewer_, V_2026_0, device_type_, npu_qdq_optimizer_enabled);
-#elif OPENVINO_VERSION_MAJOR == 2025 && OPENVINO_VERSION_MINOR == 4
-  data_ops_ = std::make_unique<DataOps>(graph_viewer_, V_2025_4, device_type_, npu_qdq_optimizer_enabled);
-#elif OPENVINO_VERSION_MAJOR == 2025 && OPENVINO_VERSION_MINOR == 3
-  data_ops_ = std::make_unique<DataOps>(graph_viewer_, V_2025_3, device_type_, npu_qdq_optimizer_enabled);
 #else
-  data_ops_ = std::make_unique<DataOps>(graph_viewer_, V_2026_1, device_type_, npu_qdq_optimizer_enabled);
+  data_ops_ = std::make_unique<DataOps>(graph_viewer_, V_2026_2, device_type_, npu_qdq_optimizer_enabled);
 #endif
 }
 

onnxruntime/core/providers/openvino/ov_versions/data_ops.cc

@@ -408,7 +408,7 @@ void DataOps::populate_op_mode_supported() {
 
   // populate unsupportedmode_t
   {
-    UnsupportedOpMode obj = {{V_2024_1, V_2024_2, V_2024_3, V_2024_4, V_2024_5, V_2024_6, V_2025_0, V_2025_1, V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1},
+    UnsupportedOpMode obj = {{V_2024_1, V_2024_2, V_2024_3, V_2024_4, V_2024_5, V_2024_6, V_2025_0, V_2025_1, V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1, V_2026_2},
                              [this](const Node* node, const InitializedTensorSet&) {
                                // If the Input of ReduceMax op is UINT8, it is rejected (Due to output mismatch)
                                for (size_t i = 0; i < node->InputDefs().size(); i++) {
@@ -425,7 +425,7 @@ void DataOps::populate_op_mode_supported() {
   {
     UnsupportedOpMode obj = {{V_2023_1, V_2023_2, V_2023_3, V_2024_0, V_2024_1, V_2024_2,
                               V_2024_3, V_2024_4, V_2024_5, V_2024_6, V_2025_0, V_2025_1,
-                              V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1},
+                              V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1, V_2026_2},
                              [this](const Node* node, const InitializedTensorSet&) {
                                const auto& input_args = node->InputDefs();
                                const auto& input_arg = (input_args.size() > 1) ? input_args[1] : input_args[0];
@@ -445,7 +445,7 @@ void DataOps::populate_op_mode_supported() {
   {
     UnsupportedOpMode obj = {{V_2023_1, V_2023_2, V_2023_3, V_2024_0, V_2024_1, V_2024_2,
                               V_2024_3, V_2024_4, V_2024_5, V_2024_6, V_2025_0, V_2025_1,
-                              V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1},
+                              V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1, V_2026_2},
                              [this](const Node* node, const InitializedTensorSet&) {
                                // If the operator is unsqueeze
                                // If axes is an input, then we cannot produce a static graph.
@@ -461,7 +461,7 @@ void DataOps::populate_op_mode_supported() {
   }
   {
     UnsupportedOpMode obj = {{V_2023_1, V_2023_2, V_2023_3, V_2024_0, V_2024_1, V_2024_2, V_2024_3, V_2024_4, V_2024_5,
-                              V_2024_6, V_2025_0, V_2025_1, V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1},
+                              V_2024_6, V_2025_0, V_2025_1, V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1, V_2026_2},
                              [this](const Node* node, const InitializedTensorSet&) {
                                // check for attributes
                                auto& upsample_attr = node->GetAttributes();
@@ -492,7 +492,7 @@ void DataOps::populate_op_mode_supported() {
   {
     UnsupportedOpMode obj = {{V_2023_1, V_2023_2, V_2023_3, V_2024_0, V_2024_1, V_2024_2,
                               V_2024_3, V_2024_4, V_2024_5, V_2024_6, V_2025_0, V_2025_1,
-                              V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1},
+                              V_2025_2, V_2025_3, V_2025_4, V_2026_0, V_2026_1, V_2026_2},
                              [this](const Node* node, const InitializedTensorSet&) {
                                auto& attributes = node->GetAttributes();
                                if (attributes.count("coordinate_transformation_mode") > 0) {

onnxruntime/core/providers/openvino/ov_versions/data_ops.h

@@ -40,7 +40,8 @@ enum versionNum {
   V_2025_3,
   V_2025_4,
   V_2026_0,
-  V_2026_1
+  V_2026_1,
+  V_2026_2
 };
 
 using VersionNum = enum versionNum;

onnxruntime/test/providers/openvino/openvino_ep_context_test.cc

@@ -1,8 +1,11 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+#include <array>
 #include <filesystem>
 #include <string>
+#include <unordered_map>
+#include <vector>
 
 #include "core/framework/provider_options.h"
 #include "core/framework/tensor_shape.h"
@@ -26,6 +29,34 @@ using namespace onnxruntime::logging;
 
 extern std::unique_ptr<Ort::Env> ort_env;
 
+namespace {
+
+// Runs a mul_1-style model (X[3,2] -> Y[3,2], Y = X * {1,2,3,4,5,6}) with
+// X = all 2.0f and validates that Y == {2,4,6,8,10,12}.
+void RunAndValidate(Ort::Session& session) {
+  const std::array<int64_t, 2> input_shape = {3, 2};
+  std::vector<float> input_data(6, 2.0f);
+  Ort::MemoryInfo mem_info = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtDeviceAllocator, OrtMemTypeDefault);
+  Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
+      mem_info, input_data.data(), input_data.size(), input_shape.data(), input_shape.size());
+
+  const std::array<const char*, 1> input_names = {"X"};
+  const std::array<const char*, 1> output_names = {"Y"};
+  std::vector<Ort::Value> output_tensors(1);
+
+  session.Run(Ort::RunOptions{nullptr}, input_names.data(), &input_tensor, 1,
+              output_names.data(), output_tensors.data(), 1);
+
+  ASSERT_TRUE(output_tensors[0].IsTensor());
+  ASSERT_EQ(output_tensors[0].GetTensorTypeAndShapeInfo().GetElementCount(), 6u);
+
+  const float* out_data = output_tensors[0].GetTensorData<float>();
+  EXPECT_THAT(std::vector<float>(out_data, out_data + 6),
+              ::testing::ElementsAre(2.f, 4.f, 6.f, 8.f, 10.f, 12.f));
+}
+
+}  // namespace
+
 class OVEPEPContextTests : public ::testing::Test {
 };
 
@@ -72,5 +103,107 @@ TEST_F(OVEPEPContextTests, OVEPEPContextFolderPath) {
   }
 }
 
+// Runs an existing OVIR-encapsulated EP context model: "mul_1_ep_ctx_ovir.onnx"
+// wraps a single EPContext node whose "ep_cache_context" points to a sibling
+// OpenVINO IR (".xml" + ".bin"), so OVEP imports it via read_model()/
+// compile_model() instead of a pre-compiled blob.
+//
+// OVIR detection is filename-based (".onnx" -> ".xml"), so the model must be
+// loaded from a path with the ".xml"/".bin" siblings next to it.
+//
+// CPU only.
+class OVEPEPContextOVIRTests : public ::testing::Test {
+ protected:
+  static constexpr const char* kDevice = "CPU";
+  static constexpr const ORTCHAR_T* kOvirModelPath = ORT_TSTR("testdata/mul_1_ep_ctx_ovir.onnx");
+};
+
+TEST_F(OVEPEPContextOVIRTests, RunEpCtxOvirModel) {
+  ASSERT_TRUE(std::filesystem::exists(kOvirModelPath))
+      << "Missing OVIR EP context model. Expected testdata/mul_1_ep_ctx_ovir.onnx "
+         "(with sibling .xml and .bin files).";
+
+  // Set up session options targeting CPU.
+  Ort::SessionOptions session_options;
+  std::unordered_map<std::string, std::string> ov_options = {{"device_type", kDevice}};
+  session_options.AppendExecutionProvider_OpenVINO_V2(ov_options);
+
+  // Load the OVIR EP context model from disk (path-based load is required for
+  // OVIR encapsulation detection).
+  Ort::Session session(*ort_env, kOvirModelPath, session_options);
+
+  RunAndValidate(session);
+}
+
+// Generates an EP context model from the OVIR-encapsulated source model and
+// then loads + runs the generated model, covering both EP context embed modes:
+//   embed_mode = 1: the compiled context is serialized INLINE into the .onnx.
+//   embed_mode = 0: the compiled context is dumped to a separate file and only
+//                   its filename is stored in the .onnx EPContext node.
+//
+// embed_mode is only honored during generation (it is written into the
+// EPContext node), so it must be exercised via a generate-then-run flow rather
+// than by setting the option on a run-only session.
+//
+// CPU only. Parameter: embed_mode_enabled.
+class OVEPOVIRModelsExportEPContextTests : public ::testing::TestWithParam<bool> {
+ protected:
+  static constexpr const char* kDevice = "CPU";
+  static constexpr const ORTCHAR_T* kOvirModelPath = ORT_TSTR("testdata/mul_1_ep_ctx_ovir.onnx");
+};
+
+TEST_P(OVEPOVIRModelsExportEPContextTests, ExportEpCtxFromOVIRModel) {
+  const bool embed_mode = GetParam();
+
+  ASSERT_TRUE(std::filesystem::exists(kOvirModelPath))
+      << "Missing OVIR EP context model. Expected testdata/mul_1_ep_ctx_ovir.onnx "
+         "(with sibling .xml and .bin files).";
+
+  // Generate the EP context model into a dedicated subfolder so that the
+  // separately-dumped blob (embed_mode = 0) doesn't collide with testdata.
+  const std::filesystem::path out_dir =
+      std::filesystem::path("testdata") / (std::string("ovir_epctx_export_embed_") + (embed_mode ? "on" : "off"));
+  std::filesystem::remove_all(out_dir);
+  std::filesystem::create_directories(out_dir);
+  const std::filesystem::path epctx_model = out_dir / "mul_1_ovir_epctx_export.onnx";
+
+  // --- Generate EP context model ---
+  {
+    Ort::SessionOptions session_options;
+    session_options.AddConfigEntry(kOrtSessionOptionEpContextEnable, "1");
+    session_options.AddConfigEntry(kOrtSessionOptionEpContextFilePath, epctx_model.string().c_str());
+    session_options.AddConfigEntry(kOrtSessionOptionEpContextEmbedMode, embed_mode ? "1" : "0");
+    std::unordered_map<std::string, std::string> ov_options = {{"device_type", kDevice}};
+    session_options.AppendExecutionProvider_OpenVINO_V2(ov_options);
+
+    // Creating the session triggers EP context export to epctx_model.
+    Ort::Session session(*ort_env, kOvirModelPath, session_options);
+  }
+
+  ASSERT_TRUE(std::filesystem::exists(epctx_model))
+      << "EP context model was not generated at " << epctx_model;
+
+  // --- Load + run the generated EP context model ---
+  {
+    Ort::SessionOptions session_options;
+    std::unordered_map<std::string, std::string> ov_options = {{"device_type", kDevice}};
+    session_options.AppendExecutionProvider_OpenVINO_V2(ov_options);
+
+    Ort::Session session(*ort_env, epctx_model.c_str(), session_options);
+
+    RunAndValidate(session);
+  }
+
+  std::filesystem::remove_all(out_dir);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    OVEP_Tests,
+    OVEPOVIRModelsExportEPContextTests,
+    ::testing::Bool(),
+    [](const ::testing::TestParamInfo<OVEPOVIRModelsExportEPContextTests::ParamType>& info) {
+      return std::string("embed_") + (info.param ? "on" : "off");
+    });
+
 }  // namespace test
 }  // namespace onnxruntime