diff --git a/level_zero/api/core/preview_api_entrypoints.h b/level_zero/api/core/preview_api_entrypoints.h
new file mode 100644
index 0000000000..32cb6bf571
--- /dev/null
+++ b/level_zero/api/core/preview_api_entrypoints.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "level_zero/ze_intel_gpu.h"
+
+namespace L0 {
+
+ze_context_handle_t zeDriverGetDefaultContext(ze_driver_handle_t hDriver);
+
+ze_result_t zeDeviceSynchronize(ze_device_handle_t hDevice);
+
+ze_result_t zeCommandListAppendLaunchKernelWithParameters(
+    ze_command_list_handle_t hCommandList,
+    ze_kernel_handle_t hKernel,
+    const ze_group_count_t *pGroupCounts,
+    const void *pNext,
+    ze_event_handle_t hSignalEvent,
+    uint32_t numWaitEvents,
+    ze_event_handle_t *phWaitEvents);
+
+ze_result_t zeCommandListAppendLaunchKernelWithArguments(
+    ze_command_list_handle_t hCommandList,
+    ze_kernel_handle_t hKernel,
+    const ze_group_count_t groupCounts,
+    const ze_group_size_t groupSizes,
+    void **pArguments,
+    const void *pNext,
+    ze_event_handle_t hSignalEvent,
+    uint32_t numWaitEvents,
+    ze_event_handle_t *phWaitEvents
+
+);
+
+ze_result_t zerGetLastErrorDescription(const char **ppString);
+
+uint32_t zerTranslateDeviceHandleToIdentifier(ze_device_handle_t device);
+
+ze_device_handle_t zerTranslateIdentifierToDeviceHandle(uint32_t identifier);
+
+ze_context_handle_t zerGetDefaultContext();
+} // namespace L0
diff --git a/level_zero/core/source/driver/extension_function_address.cpp b/level_zero/core/source/driver/extension_function_address.cpp
index 7864f8ace7..24f574c104 100644
--- a/level_zero/core/source/driver/extension_function_address.cpp
+++ b/level_zero/core/source/driver/extension_function_address.cpp
@@ -7,6 +7,7 @@
 
 #include "level_zero/core/source/driver/extension_function_address.h"
 
+#include "level_zero/api/core/preview_api_entrypoints.h"
 #include "level_zero/api/extensions/public/ze_exp_ext.h"
 #include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_ext.h"
 #include "level_zero/driver_experimental/zex_api.h"
@@ -27,12 +28,29 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str
         }                                 \
     }
 
+#define RETURN_L0_FUNC_PTR_IF_EXIST(name)     \
+    {                                         \
+        if (functionName == #name) {          \
+            void *ret = ((void *)(L0::name)); \
+            return ret;                       \
+        }                                     \
+    }
+
     RETURN_FUNC_PTR_IF_EXIST(zexDriverImportExternalPointer);
     RETURN_FUNC_PTR_IF_EXIST(zexDriverReleaseImportedPointer);
     RETURN_FUNC_PTR_IF_EXIST(zexDriverGetHostPointerBaseAddress);
+    RETURN_L0_FUNC_PTR_IF_EXIST(zeDriverGetDefaultContext);
+    RETURN_L0_FUNC_PTR_IF_EXIST(zerGetDefaultContext);
+    RETURN_L0_FUNC_PTR_IF_EXIST(zerGetLastErrorDescription);
 
+    RETURN_L0_FUNC_PTR_IF_EXIST(zerTranslateDeviceHandleToIdentifier);
+    RETURN_L0_FUNC_PTR_IF_EXIST(zerTranslateIdentifierToDeviceHandle);
+    RETURN_L0_FUNC_PTR_IF_EXIST(zeDeviceSynchronize);
     RETURN_FUNC_PTR_IF_EXIST(zeDeviceGetPriorityLevels);
 
+    RETURN_L0_FUNC_PTR_IF_EXIST(zeCommandListAppendLaunchKernelWithArguments);
+    RETURN_L0_FUNC_PTR_IF_EXIST(zeCommandListAppendLaunchKernelWithParameters);
+
     RETURN_FUNC_PTR_IF_EXIST(zexKernelGetBaseAddress);
     RETURN_FUNC_PTR_IF_EXIST(zexKernelGetArgumentSize);
     RETURN_FUNC_PTR_IF_EXIST(zexKernelGetArgumentType);
@@ -132,6 +150,7 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str
     RETURN_FUNC_PTR_IF_EXIST(zeGraphDumpContentsExp);
 
 #undef RETURN_FUNC_PTR_IF_EXIST
+#undef RETURN_L0_FUNC_PTR_IF_EXIST
 
     return ExtensionFunctionAddressHelper::getAdditionalExtensionFunctionAddress(functionName);
 }
diff --git a/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp b/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
index 8ec5575cc3..7318afe93c 100644
--- a/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
+++ b/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
@@ -32,6 +32,7 @@
 #include "shared/test/common/mocks/ult_device_factory.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
+#include "level_zero/api/core/preview_api_entrypoints.h"
 #include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/core/source/driver/driver_imp.h"
@@ -1341,6 +1342,16 @@ TEST_F(DriverExperimentalApiTest, whenRetrievingApiFunctionThenExpectProperPoint
     decltype(&zexDriverImportExternalPointer) expectedImport = zexDriverImportExternalPointer;
     decltype(&zexDriverReleaseImportedPointer) expectedRelease = zexDriverReleaseImportedPointer;
     decltype(&zexDriverGetHostPointerBaseAddress) expectedGet = zexDriverGetHostPointerBaseAddress;
+    decltype(&zeDriverGetDefaultContext) expectedZeDriverGetDefaultContext = L0::zeDriverGetDefaultContext;
+    decltype(&zerGetDefaultContext) expectedZerGetDefaultContext = L0::zerGetDefaultContext;
+    decltype(&zerGetLastErrorDescription) expectedZerGetLastErrorDescription = L0::zerGetLastErrorDescription;
+
+    decltype(&zerTranslateDeviceHandleToIdentifier) expectedZerTranslateDeviceHandleToIdentifier = L0::zerTranslateDeviceHandleToIdentifier;
+    decltype(&zerTranslateIdentifierToDeviceHandle) expectedZerTranslateIdentifierToDeviceHandle = L0::zerTranslateIdentifierToDeviceHandle;
+    decltype(&zeDeviceSynchronize) expectedZeDeviceSynchronize = L0::zeDeviceSynchronize;
+
+    decltype(&zeCommandListAppendLaunchKernelWithArguments) expectedZeCommandListAppendLaunchKernelWithArguments = L0::zeCommandListAppendLaunchKernelWithArguments;
+    decltype(&zeCommandListAppendLaunchKernelWithParameters) expectedZeCommandListAppendLaunchKernelWithParameters = L0::zeCommandListAppendLaunchKernelWithParameters;
 
     decltype(&zexKernelGetBaseAddress) expectedKernelGetBaseAddress = zexKernelGetBaseAddress;
     decltype(&zeIntelGetDriverVersionString) expectedIntelGetDriverVersionString = zeIntelGetDriverVersionString;
@@ -1396,6 +1407,30 @@ TEST_F(DriverExperimentalApiTest, whenRetrievingApiFunctionThenExpectProperPoint
     EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zexDriverGetHostPointerBaseAddress", &funPtr));
     EXPECT_EQ(expectedGet, reinterpret_cast<decltype(&zexDriverGetHostPointerBaseAddress)>(funPtr));
 
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zeDriverGetDefaultContext", &funPtr));
+    EXPECT_EQ(expectedZeDriverGetDefaultContext, reinterpret_cast<decltype(&zeDriverGetDefaultContext)>(funPtr));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zerGetDefaultContext", &funPtr));
+    EXPECT_EQ(expectedZerGetDefaultContext, reinterpret_cast<decltype(&zerGetDefaultContext)>(funPtr));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zerGetLastErrorDescription", &funPtr));
+    EXPECT_EQ(expectedZerGetLastErrorDescription, reinterpret_cast<decltype(&zerGetLastErrorDescription)>(funPtr));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zerTranslateDeviceHandleToIdentifier", &funPtr));
+    EXPECT_EQ(expectedZerTranslateDeviceHandleToIdentifier, reinterpret_cast<decltype(&zerTranslateDeviceHandleToIdentifier)>(funPtr));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zerTranslateIdentifierToDeviceHandle", &funPtr));
+    EXPECT_EQ(expectedZerTranslateIdentifierToDeviceHandle, reinterpret_cast<decltype(&zerTranslateIdentifierToDeviceHandle)>(funPtr));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zeDeviceSynchronize", &funPtr));
+    EXPECT_EQ(expectedZeDeviceSynchronize, reinterpret_cast<decltype(&zeDeviceSynchronize)>(funPtr));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zeCommandListAppendLaunchKernelWithArguments", &funPtr));
+    EXPECT_EQ(expectedZeCommandListAppendLaunchKernelWithArguments, reinterpret_cast<decltype(&zeCommandListAppendLaunchKernelWithArguments)>(funPtr));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zeCommandListAppendLaunchKernelWithParameters", &funPtr));
+    EXPECT_EQ(expectedZeCommandListAppendLaunchKernelWithParameters, reinterpret_cast<decltype(&zeCommandListAppendLaunchKernelWithParameters)>(funPtr));
+
     EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGetExtensionFunctionAddress(driverHandle, "zexKernelGetBaseAddress", &funPtr));
     EXPECT_EQ(expectedKernelGetBaseAddress, reinterpret_cast<decltype(&zexKernelGetBaseAddress)>(funPtr));