Restore WinML bootstrap auto-detection

Restore the bootstrap auto-detection behavior that 4a7dde2 removed across the C#, JS, Python, and Rust SDKs, while leaving the C# WinML minimum-version alignment intact.

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

Author: bmehta001

sdk/cs/src/Detail/CoreInterop.cs

@@ -125,6 +125,14 @@ internal CoreInterop(Configuration config, ILogger logger)
 
         var request = new CoreInteropRequest { Params = config.AsDictionary() };
 
+#if IS_WINML
+        // WinML builds require bootstrapping the Windows App Runtime
+        if (!request.Params.ContainsKey("Bootstrap"))
+        {
+            request.Params["Bootstrap"] = "true";
+        }
+#endif
+
         var response = ExecuteCommand("initialize", request);
 
         if (response.Error != null)

sdk/js/src/detail/coreInterop.ts

@@ -50,6 +50,17 @@ export class CoreInterop {
         const corePath = path.join(packageDir, `Microsoft.AI.Foundry.Local.Core${ext}`);
         if (fs.existsSync(corePath)) {
             config.params['FoundryLocalCorePath'] = corePath;
+
+            // Auto-detect if WinML Bootstrap is needed by checking for Bootstrap DLL in FoundryLocalCorePath
+            // Only auto-set if the user hasn't explicitly provided a value
+            if (!('Bootstrap' in config.params)) {
+                const bootstrapDllPath = path.join(packageDir, 'Microsoft.WindowsAppRuntime.Bootstrap.dll');
+                if (fs.existsSync(bootstrapDllPath)) {
+                    // WinML Bootstrap DLL found, enable bootstrapping
+                    config.params['Bootstrap'] = 'true';
+                }
+            }
+            
             return corePath;
         }
 

sdk/js/test/testUtils.ts

@@ -34,7 +34,8 @@ export const TEST_CONFIG: FoundryLocalConfig = {
     appName: 'FoundryLocalTest',
     modelCacheDir: getTestDataSharedPath(),
     logLevel: 'warn',
-    logsDir: path.join(getGitRepoRoot(), 'sdk', 'js', 'logs')
+    logsDir: path.join(getGitRepoRoot(), 'sdk', 'js', 'logs'),
+    additionalSettings: { 'Bootstrap': 'false' }
 };
 
 export const TEST_MODEL_ALIAS = 'qwen2.5-0.5b';

sdk/python/README.md

@@ -29,7 +29,7 @@ pip install foundry-local-sdk
 pip install foundry-local-sdk-winml
 ```
 
-Each package installs the correct native binaries (`foundry-local-core`, `onnxruntime-core`, `onnxruntime-genai-core`) as wheel dependencies. They are mutually exclusive — install only one per environment. The WinML package carries the reg-free WinML runtime app-locally, so no Windows App Runtime bootstrap step is required.
+Each package installs the correct native binaries (`foundry-local-core`, `onnxruntime-core`, `onnxruntime-genai-core`) as wheel dependencies.  They are mutually exclusive — install only one per environment.  WinML is auto-detected at runtime: if the WinML package is installed, the SDK automatically enables the Windows App Runtime Bootstrap.
 
 ### Building from source
 
@@ -154,6 +154,7 @@ config = Configuration(
     app_name="MyApp",
     model_cache_dir="/path/to/cache",     # optional
     log_level=LogLevel.INFORMATION,        # optional (default: Warning)
+    additional_settings={"Bootstrap": "false"},  # optional
 )
 FoundryLocalManager.initialize(config)
 manager = FoundryLocalManager.instance
@@ -303,4 +304,4 @@ See [test/README.md](test/README.md) for detailed test setup and structure.
 
 ```bash
 python examples/chat_completion.py
-```
+```

sdk/python/src/detail/core_interop.py

@@ -202,6 +202,21 @@ def __init__(self, config: Configuration):
             config.additional_settings["OrtLibraryPath"] = str(paths.ort)
             config.additional_settings["OrtGenAILibraryPath"] = str(paths.genai)
 
+            # Auto-detect WinML Bootstrap: if the Bootstrap DLL is present
+            # in the native binaries directory and the user hasn't explicitly
+            # set the Bootstrap config, enable it automatically.
+            if sys.platform.startswith("win"):
+                bootstrap_dll = paths.core_dir / "Microsoft.WindowsAppRuntime.Bootstrap.dll"
+                if bootstrap_dll.exists():
+                    # Pre-load so the DLL is already in the process when
+                    # C# P/Invoke resolves it during Bootstrap.Initialize().
+                    ctypes.CDLL(str(bootstrap_dll))
+                    if config.additional_settings is None:
+                        config.additional_settings = {}
+                    if "Bootstrap" not in config.additional_settings:
+                        logger.info("WinML Bootstrap DLL detected — enabling Bootstrap")
+                        config.additional_settings["Bootstrap"] = "true"
+
         request = InteropRequest(params=config.as_dictionary())
         response = self.execute_command("initialize", request)
         if response.error is not None:

sdk/python/test/conftest.py

@@ -65,6 +65,7 @@ def get_test_config() -> Configuration:
         model_cache_dir=get_test_data_shared_path(),
         log_level=LogLevel.WARNING,
         logs_dir=str(repo_root / "sdk" / "python" / "logs"),
+        additional_settings={"Bootstrap": "false"},
     )
 
 

sdk/rust/src/configuration.rs

@@ -228,10 +228,10 @@ mod tests {
     #[test]
     fn builder_additional_settings() {
         let cfg = FoundryLocalConfig::new("App")
-            .additional_setting("ExampleSetting", "value")
+            .additional_setting("Bootstrap", "false")
             .additional_setting("Foo", "bar");
         let (c, _) = Configuration::new(cfg).unwrap();
-        assert_eq!(c.params["ExampleSetting"], "value");
+        assert_eq!(c.params["Bootstrap"], "false");
         assert_eq!(c.params["Foo"], "bar");
     }
 }

sdk/rust/src/detail/core_interop.rs

@@ -255,6 +255,21 @@ impl CoreInterop {
     pub fn new(config: &mut Configuration) -> Result<Self> {
         let lib_path = Self::resolve_library_path(config)?;
 
+        // Auto-detect WinAppSDK Bootstrap DLL next to the core library.
+        // If present, tell the native core to run the bootstrapper during
+        // initialisation — this is required for WinML execution providers.
+        #[cfg(target_os = "windows")]
+        if !config.params.contains_key("Bootstrap") {
+            if let Some(dir) = lib_path.parent() {
+                if dir
+                    .join("Microsoft.WindowsAppRuntime.Bootstrap.dll")
+                    .exists()
+                {
+                    config.params.insert("Bootstrap".into(), "true".into());
+                }
+            }
+        }
+
         #[cfg(target_os = "windows")]
         let _dependency_libs = Self::load_windows_dependencies(&lib_path)?;
 
@@ -576,6 +591,16 @@ impl CoreInterop {
 
         let mut libs = Vec::new();
 
+        // Load WinML bootstrap if present.
+        let bootstrap = dir.join("Microsoft.WindowsAppRuntime.Bootstrap.dll");
+        if bootstrap.exists() {
+            // SAFETY: Pre-loading a known dependency DLL from the same trusted
+            // directory as the core library.
+            if let Ok(lib) = unsafe { Library::new(&bootstrap) } {
+                libs.push(lib);
+            }
+        }
+
         for dep in &["onnxruntime.dll", "onnxruntime-genai.dll"] {
             let dep_path = dir.join(dep);
             if dep_path.exists() {

sdk/rust/tests/integration/common/mod.rs

@@ -68,6 +68,7 @@ pub fn get_audio_file_path() -> PathBuf {
 /// * `modelCacheDir`  → `<repo-root>/../test-data-shared`
 /// * `logsDir`        → `<repo-root>/sdk/rust/logs`
 /// * `logLevel`       → `Warn`
+/// * `Bootstrap`      → `false` (via additional settings)
 pub fn test_config() -> FoundryLocalConfig {
     let repo_root = get_git_repo_root();
     let logs_dir = repo_root.join("sdk").join("rust").join("logs");
@@ -76,6 +77,7 @@ pub fn test_config() -> FoundryLocalConfig {
         .model_cache_dir(get_test_data_shared_path().to_string_lossy().into_owned())
         .logs_dir(logs_dir.to_string_lossy().into_owned())
         .log_level(LogLevel::Warn)
+        .additional_setting("Bootstrap", "false")
 }
 
 /// Create (or return the cached) [`FoundryLocalManager`] for tests.