Address PR feedback: remove DLL workarounds, keep output queue readable after stop

- Remove _load_dll_win() and SetDllDirectoryW (B1/B2 feedback from baijumeswani)
- Remove DLL preload from test/conftest.py (B10)
- Keep _output_queue intact after stop() so completed stream stays readable,
  matching C#/JS SDK behavior (bmehta001 feedback)
- Bump foundry-local-core to 1.0.0.dev202604082039

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ruiren_microsoft

sdk/python/requirements-winml.txt

@@ -2,6 +2,6 @@ pydantic>=2.0.0
 requests>=2.32.4
 openai>=2.24.0
 # WinML native binary packages from the ORT-Nightly PyPI feed.
-foundry-local-core-winml==1.0.0rc1
+foundry-local-core-winml==1.0.0.dev202604082039
 onnxruntime-core==1.23.2.3
 onnxruntime-genai-core==0.13.1

sdk/python/requirements.txt

@@ -2,7 +2,7 @@ pydantic>=2.0.0
 requests>=2.32.4
 openai>=2.24.0
 # Standard native binary packages from the ORT-Nightly PyPI feed.
-foundry-local-core==1.0.0rc1
+foundry-local-core==1.0.0.dev202604082039
 onnxruntime-core==1.24.4; sys_platform != "linux"
 onnxruntime-gpu==1.24.4; sys_platform == "linux"
 onnxruntime-genai-core==0.13.1; sys_platform != "linux"

sdk/python/src/detail/core_interop.py

@@ -125,32 +125,6 @@ class CoreInterop:
     # Returns c_int: 0 = continue, 1 = cancel.
     CALLBACK_TYPE = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p)
 
-    @staticmethod
-    def _load_dll_win(dll_path: str):
-        """Load a DLL on Windows using ``LOAD_WITH_ALTERED_SEARCH_PATH``.
-
-        This flag tells Windows to resolve the DLL's dependencies starting from
-        the DLL's own directory rather than the process's default search path.
-        Prevents conflicts with stale same-named DLLs in system directories
-        (e.g. an old onnxruntime.dll in system32).
-
-        The DLL is first loaded via ``LoadLibraryExW`` (which maps it into the
-        process), then wrapped in a ``ctypes.CDLL`` for Python access.
-        """
-        kernel32 = ctypes.windll.kernel32
-        kernel32.LoadLibraryExW.restype = ctypes.c_void_p
-        kernel32.LoadLibraryExW.argtypes = [ctypes.c_wchar_p, ctypes.c_void_p, ctypes.c_int]
-        _LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008
-
-        handle = kernel32.LoadLibraryExW(dll_path, None, _LOAD_WITH_ALTERED_SEARCH_PATH)
-        if not handle:
-            logger.warning("LoadLibraryExW failed for %s (error %d), falling back to ctypes.CDLL",
-                           dll_path, kernel32.GetLastError())
-            return ctypes.CDLL(dll_path)
-
-        # DLL is now mapped; ctypes.CDLL will reuse the loaded module
-        return ctypes.CDLL(dll_path)
-
     @staticmethod
     def _initialize_native_libraries() -> 'NativeBinaryPaths':
         """Load the native Foundry Local Core library and its dependencies.
@@ -185,20 +159,15 @@ def _initialize_native_libraries() -> 'NativeBinaryPaths':
             for native_dir in paths.all_dirs():
                 os.add_dll_directory(str(native_dir))
 
-            # Set the DLL search directory so that when ORT/GenAI load their
-            # own dependencies, they find sibling DLLs from the correct
-            # directory rather than stale copies in system directories.
-            ctypes.windll.kernel32.SetDllDirectoryW(str(paths.ort_dir))
-
         # Explicitly pre-load ORT and GenAI so their symbols are globally
         # available when Core does P/Invoke lookups at runtime.
         # On Windows the PATH manipulation above is sufficient; on
         # Linux/macOS we need RTLD_GLOBAL so that dlopen() within the
         # Core native code can resolve ORT/GenAI symbols.
         # ORT must be loaded before GenAI (GenAI depends on ORT).
         if sys.platform.startswith("win"):
-            CoreInterop._ort_library = CoreInterop._load_dll_win(str(paths.ort))
-            CoreInterop._genai_library = CoreInterop._load_dll_win(str(paths.genai))
+            CoreInterop._ort_library = ctypes.CDLL(str(paths.ort))
+            CoreInterop._genai_library = ctypes.CDLL(str(paths.genai))
         else:
             CoreInterop._ort_library = ctypes.CDLL(str(paths.ort), mode=os.RTLD_GLOBAL)
             CoreInterop._genai_library = ctypes.CDLL(str(paths.genai), mode=os.RTLD_GLOBAL)

sdk/python/src/openai/live_audio_transcription_client.py

@@ -236,11 +236,11 @@ def stop(self) -> None:
         # 4. Complete the output queue
         self._output_queue.put(_SENTINEL)
 
-        # 5. Clean up — set _output_queue to None so subsequent calls to
-        # get_transcription_stream() fail fast instead of hanging.
+        # 5. Clean up — keep _output_queue intact so that
+        # get_transcription_stream() returns an empty stream (matching C#/JS
+        # behavior where the completed stream remains readable).
         self._session_handle = None
         self._started = False
-        self._output_queue = None
 
         if response.error is not None:
             raise FoundryLocalException(

sdk/python/test/conftest.py

@@ -16,14 +16,15 @@
 import logging
 import sys
 
-# ---------------------------------------------------------------------------
-# Pre-load ORT/GenAI DLLs from e2e-test-pkgs BEFORE importing the SDK.
-#
-# The ``_brotli`` C extension (pulled in by httpx → openai → SDK) calls
-# ``SetDefaultDllDirectories`` during import, which restricts subsequent
-# ``LoadLibraryExW`` calls. Pre-loading here ensures ORT/GenAI are already
-# in the process before brotli changes the DLL search behavior.
-# ---------------------------------------------------------------------------
+import pytest
+
+from pathlib import Path
+
+from foundry_local_sdk.configuration import Configuration, LogLevel
+from foundry_local_sdk.foundry_local_manager import FoundryLocalManager
+
+logger = logging.getLogger(__name__)
+
 
 def _get_e2e_test_pkgs_path():
     """Locate the e2e-test-pkgs directory by walking up from this file."""
@@ -38,40 +39,6 @@ def _get_e2e_test_pkgs_path():
             return None
         current = parent
 
-if sys.platform.startswith("win"):
-    import ctypes
-
-    def _preload_e2e_dlls():
-        pkgs = _get_e2e_test_pkgs_path()
-        if pkgs is None:
-            return
-
-        ort_dll = pkgs / "onnxruntime.dll"
-        genai_dll = pkgs / "onnxruntime-genai.dll"
-        if not (ort_dll.exists() and genai_dll.exists()):
-            return
-
-        kernel32 = ctypes.windll.kernel32
-        kernel32.SetDllDirectoryW(str(pkgs))
-        os.add_dll_directory(str(pkgs))
-        os.environ["ORT_LIB_PATH"] = str(ort_dll)
-
-        kernel32.LoadLibraryExW.restype = ctypes.c_void_p
-        kernel32.LoadLibraryExW.argtypes = [ctypes.c_wchar_p, ctypes.c_void_p, ctypes.c_int]
-        kernel32.LoadLibraryExW(str(ort_dll), None, 0x00000008)
-        kernel32.LoadLibraryExW(str(genai_dll), None, 0x00000008)
-
-    _preload_e2e_dlls()
-
-import pytest
-
-from pathlib import Path
-
-from foundry_local_sdk.configuration import Configuration, LogLevel
-from foundry_local_sdk.foundry_local_manager import FoundryLocalManager
-
-logger = logging.getLogger(__name__)
-
 TEST_MODEL_ALIAS = "qwen2.5-0.5b"
 AUDIO_MODEL_ALIAS = "whisper-tiny"
 EMBEDDING_MODEL_ALIAS = "qwen3-0.6b-embedding-generic-cpu"
@@ -206,11 +173,10 @@ def model_load_manager(manager):
 # ---------------------------------------------------------------------------
 
 def _preload_and_init_e2e():
-    """Pre-load DLLs from e2e-test-pkgs and initialize the SDK for E2E tests.
+    """Load DLLs from e2e-test-pkgs and initialize the SDK for E2E tests.
 
-    Checks whether ORT is already loaded in the process (from the DLL preload
-    above) and skips the pre-load if so.  Then loads Core.dll, sets up FFI
-    function signatures, and initializes FoundryLocalManager.
+    Loads Core.dll, sets up FFI function signatures, and initializes
+    FoundryLocalManager pointing at the e2e-test-pkgs models directory.
     """
     import ctypes
     from foundry_local_sdk.detail.core_interop import (
@@ -234,29 +200,16 @@ def _preload_and_init_e2e():
     if not (paths.core.exists() and paths.ort.exists() and paths.genai.exists()):
         return None, "E2E DLLs not found"
 
-    kernel32 = ctypes.windll.kernel32
-
-    # Check if ORT is already loaded (e.g. from conftest preload)
-    kernel32.GetModuleHandleW.restype = ctypes.c_void_p
-    kernel32.GetModuleHandleW.argtypes = [ctypes.c_wchar_p]
-    ort_already_loaded = bool(kernel32.GetModuleHandleW("onnxruntime.dll"))
+    # Register directory so Core.dll can find ORT/GenAI via P/Invoke
+    os.add_dll_directory(str(pkgs))
+    os.environ["ORT_LIB_PATH"] = str(paths.ort)
 
-    if not ort_already_loaded:
-        kernel32.SetDllDirectoryW(str(pkgs))
-        os.add_dll_directory(str(pkgs))
-        os.environ["ORT_LIB_PATH"] = str(paths.ort)
-
-        kernel32.LoadLibraryExW.restype = ctypes.c_void_p
-        kernel32.LoadLibraryExW.argtypes = [ctypes.c_wchar_p, ctypes.c_void_p, ctypes.c_int]
-        _LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008
-
-        h_ort = kernel32.LoadLibraryExW(str(paths.ort), None, _LOAD_WITH_ALTERED_SEARCH_PATH)
-        if not h_ort:
-            return None, f"Failed to load ORT (WinError {kernel32.GetLastError()})"
-
-        h_genai = kernel32.LoadLibraryExW(str(paths.genai), None, _LOAD_WITH_ALTERED_SEARCH_PATH)
-        if not h_genai:
-            return None, f"Failed to load GenAI (WinError {kernel32.GetLastError()})"
+    # Pre-load ORT and GenAI so they are available when Core does P/Invoke
+    try:
+        ctypes.CDLL(str(paths.ort))
+        ctypes.CDLL(str(paths.genai))
+    except OSError as e:
+        return None, f"Failed to load ORT/GenAI DLLs: {e}"
 
     # Load Core.dll and set up function signatures
     CoreInterop._flcore_library = ctypes.CDLL(str(paths.core))