fix: require explicit device + ep in resolve_device; fix all callers

resolve_device(device, *, ep) now takes both device and ep as required args, so
an omission is a call error instead of a silent ep=None / device="auto". Several
callers still relied on the old defaults (latent TypeErrors) — pass ep=None
explicitly where no EP filter is intended:

- analyzer: auto-device resolution for rule-file selection
- build: the ep-is-None auto-EP resolution
- eval: device resolution
- compile stage: device resolution (EP comes from ep_config)
- test_device.py: resolve_device call sites

Also keeps the build command forwarding --ep to generate_build_config, and drops
the compile-availability gate / optimize-stage tweak from earlier on this branch
— requiring explicit device+ep is the cleaner, centralized enforcement.

Author: xieofxie

src/winml/modelkit/analyze/analyzer.py

@@ -140,10 +140,7 @@ def _build_runtime_debug_details_summary(
                     level_bucket[node_stable_key] = candidate_entry
                     continue
 
-                if (
-                    existing_entry.case_indices is None
-                    and candidate_entry.case_indices is not None
-                ):
+                if existing_entry.case_indices is None and candidate_entry.case_indices is not None:
                     existing_entry.case_indices = candidate_entry.case_indices
 
                 if existing_entry.table_path is None and candidate_entry.table_path is not None:
@@ -798,7 +795,7 @@ def analyze_from_proto(
         if device is not None and device.lower() == "auto":
             from ..sysinfo import resolve_device
 
-            resolved, _ = resolve_device("auto")
+            resolved, _ = resolve_device("auto", ep=None)
             device_to_use = resolved.upper()
             logger.info("Device 'auto' resolved to: %s", device_to_use)
         else:

src/winml/modelkit/commands/build.py

@@ -554,7 +554,7 @@ def build(
         from ..sysinfo import resolve_eps as _resolve_eps
 
         try:
-            resolved_device, _ = _resolve_device(device=device)
+            resolved_device, _ = _resolve_device(device=device, ep=None)
         except ValueError as e:
             raise click.UsageError(str(e)) from e
         device = resolved_device
@@ -642,24 +642,6 @@ def _patch_device(cfg: WinMLBuildConfig) -> None:
         except ValueError as e:
             raise click.UsageError(f"Config validation failed: {e}") from e
 
-        # Fail fast for compile builds: compilation physically instantiates the
-        # EP (EPContext), so the target EP/device must be present on this
-        # machine. Catch an unavailable combo here -- before export/optimize --
-        # instead of surfacing deep in the compile stage. A no-compile build
-        # only produces a portable, analyzed ONNX and may legitimately target a
-        # device absent on this machine (cross-compile), so it is left to run.
-        for _cfg in _configs_to_validate:
-            _compile = _cfg.compile
-            if _compile is None or _compile.ep_config is None:
-                continue
-            from ..sysinfo import resolve_device as _resolve_device_check
-
-            try:
-                _resolve_device_check(device=device or "auto", ep=_compile.ep_config.provider)
-            except ValueError as e:
-                raise click.UsageError(str(e)) from e
-            break
-
         preloaded_hf_config = _validate_loader_tasks_for_model(
             model_id=model_id,
             configs=_configs_to_validate,
@@ -1031,18 +1013,11 @@ def _on_iteration_start(iteration: int, max_iter: int) -> None:
             _header_shown[0] = False
 
         # Resolve "auto" to a concrete device once so that has_rule_data_for_ep
-        # doesn't search for non-existent "*_AUTO_*.parquet" files. Only a device
-        # name is needed (the EP comes from each analyzer callback below), so
-        # don't pass ep or availability-fail here: a no-compile cross-compile
-        # build may target a device absent on this machine (compile builds are
-        # gated earlier, before export).
+        # doesn't search for non-existent "*_AUTO_*.parquet" files.
         from ..analyze.utils.ep_utils import has_rule_data_for_ep
         from ..sysinfo import resolve_device as _resolve_device
 
-        if device and device.lower() != "auto":
-            _resolved_device = device.lower()
-        else:
-            _resolved_device, _ = _resolve_device(device="auto")
+        _resolved_device, _ = _resolve_device(device=device or "auto", ep=ep)
 
         def _on_ep_start(ep_name: EPName, operator_counts: dict) -> None:
             nonlocal _current_ep

src/winml/modelkit/commands/eval.py

@@ -364,7 +364,7 @@ def _resolve_device(cfg: WinMLEvaluationConfig) -> None:
 
     console = Console(stderr=True)
     console.print("[bold]Detecting available devices...[/bold]")
-    resolved, _ = resolve_device(cfg.device)
+    resolved, _ = resolve_device(cfg.device, ep=None)
     cfg.device = resolved
     console.print(f"[dim]Using device:[/dim] {resolved}")
 

src/winml/modelkit/compiler/stages/compile.py

@@ -176,7 +176,7 @@ def _compile_multiple(self, context: CompileContext) -> None:
         sess_options = context.shared_session_options
         if sess_options is None:
             register_execution_providers(ort=True)
-            resolved_device, _ = resolve_device(context.config.get("device", "auto"))
+            resolved_device, _ = resolve_device(context.config.get("device", "auto"), ep=None)
             ep = normalize_ep_name(ep_config.provider) or resolve_eps(resolved_device)[0]
             device_type = DEVICE_TO_DEVICE_TYPE.get(resolved_device.upper())
 

src/winml/modelkit/sysinfo/device.py

@@ -145,7 +145,7 @@ def _get_available_eps() -> frozenset[EPName]:
 
 
 def resolve_device(
-    device: str = "auto",
+    device: str,
     *,
     ep: EPNameOrAlias | None,
 ) -> tuple[str, list[str]]:

tests/unit/commands/test_build.py

@@ -1742,38 +1742,3 @@ def test_ep_forwarded_to_generate_build_config(
             )
         assert result.exit_code == 0, result.output
         assert mock_gen.call_args.kwargs["ep"] == "openvino"
-
-    def test_compile_build_unavailable_ep_fails_before_build(
-        self, tmp_path: Path, mock_run_single_build: MagicMock
-    ):
-        """A compile build whose EP isn't present fails fast, before _run_single_build.
-
-        Compilation physically instantiates the EP, so an unavailable EP must be
-        caught up front rather than deep in the compile stage.
-        """
-        cfg = _make_minimal_config_file(tmp_path, compile_section={"execution_provider": "qnn"})
-        with patch(
-            "winml.modelkit.sysinfo.resolve_device",
-            side_effect=ValueError("Requested EP 'qnn' is not available on this system."),
-        ):
-            result = _invoke([*self._base_args(cfg, tmp_path), "--ep", "qnn", "--compile"])
-        assert result.exit_code == 2, result.output
-        assert "not available on this system" in result.output
-        mock_run_single_build.assert_not_called()
-
-    def test_no_compile_build_skips_ep_availability_gate(
-        self, tmp_path: Path, mock_run_single_build: MagicMock
-    ):
-        """A no-compile build proceeds even when the EP isn't present (cross-compile).
-
-        No-compile only produces a portable, analyzed ONNX, so it must not require
-        the target EP/device to exist on the build machine.
-        """
-        cfg = _make_minimal_config_file(tmp_path, compile_section={"execution_provider": "qnn"})
-        with patch(
-            "winml.modelkit.sysinfo.resolve_device",
-            side_effect=ValueError("Requested EP 'qnn' is not available on this system."),
-        ):
-            result = _invoke([*self._base_args(cfg, tmp_path), "--ep", "qnn", "--no-compile"])
-        assert result.exit_code == 0, result.output
-        mock_run_single_build.assert_called_once()

tests/unit/sysinfo/test_device.py

@@ -83,7 +83,7 @@ def test_no_npu_no_gpu(self) -> None:
     def test_returns_empty_when_enumeration_fails(self) -> None:
         """If EP enumeration raises, return empty tuple (no devices visible).
 
-        ``resolve_device("auto")`` is responsible for the CPU fallback when no
+        ``resolve_device("auto", ep=None)`` is responsible for the CPU fallback when no
         devices are reachable; ``_get_available_devices`` only reports what is
         actually registered.
         """
@@ -214,7 +214,7 @@ def test_resolve_device_auto_npu_with_ep(self) -> None:
                 "cpu": ("CPUExecutionProvider",),
             }
         ):
-            device, available = resolve_device("auto")
+            device, available = resolve_device("auto", ep=None)
 
         assert device == "npu"
         assert available == ["npu", "gpu", "cpu"]
@@ -227,15 +227,15 @@ def test_resolve_device_auto_npu_without_ep(self) -> None:
                 "cpu": ("CPUExecutionProvider",),
             }
         ):
-            device, available = resolve_device("auto")
+            device, available = resolve_device("auto", ep=None)
 
         assert device == "gpu"
         assert available == ["gpu", "cpu"]
 
     def test_resolve_device_auto_cpu_fallback(self) -> None:
         """Auto mode: only CPU EP registered -> returns "cpu"."""
         with _patch_device_ep_map({"cpu": ("CPUExecutionProvider",)}):
-            device, available = resolve_device("auto")
+            device, available = resolve_device("auto", ep=None)
 
         assert device == "cpu"
         assert available == ["cpu"]
@@ -248,15 +248,15 @@ def test_resolve_device_explicit_valid(self) -> None:
                 "cpu": ("CPUExecutionProvider",),
             }
         ):
-            device, available = resolve_device("gpu")
+            device, available = resolve_device("gpu", ep=None)
 
         assert device == "gpu"
         assert available == ["gpu", "cpu"]
 
     def test_resolve_device_explicit_invalid(self) -> None:
         """Unrecognized device "tpu" -> raises ValueError."""
         with pytest.raises(ValueError, match="Unknown device 'tpu'"):
-            resolve_device("tpu")
+            resolve_device("tpu", ep=None)
 
     def test_resolve_device_explicit_no_ep_error_names_missing_eps(self) -> None:
         """Error message must name the compatible EPs so users know what to install."""
@@ -268,7 +268,7 @@ def test_resolve_device_explicit_no_ep_error_names_missing_eps(self) -> None:
             ),
             pytest.raises(ValueError) as exc_info,
         ):
-            resolve_device("npu")
+            resolve_device("npu", ep=None)
 
         message = str(exc_info.value)
         assert "no compatible EP" in message
@@ -278,7 +278,7 @@ def test_resolve_device_explicit_no_ep_error_names_missing_eps(self) -> None:
     def test_resolve_device_case_insensitive(self) -> None:
         """Device argument should be case-insensitive."""
         with _patch_device_ep_map({"cpu": ("CPUExecutionProvider",)}):
-            device, _ = resolve_device("CPU")
+            device, _ = resolve_device("CPU", ep=None)
 
         assert device == "cpu"
 
@@ -293,7 +293,7 @@ def test_resolve_device_no_eps_raises(self) -> None:
             _patch_device_ep_map({}),
             pytest.raises(RuntimeError, match="No execution providers detected"),
         ):
-            resolve_device("auto")
+            resolve_device("auto", ep=None)
 
 
 class TestResolveDeviceWithEp: