@camstack/addon-pipeline 1.0.2 → 1.0.3

package/dist/detection-pipeline/index.js

@@ -3896,22 +3896,68 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async setApi(addonCtx) {
 		this.addonCtx = addonCtx;
 	}
+	/**
+	* Fetch platform-probe data for engine + device gating. Returns null for
+	* both fields when the probe cap is not yet reachable (cold-start / probe
+	* addon not installed), so callers fall back to the full static catalog.
+	*/
+	async fetchProbeGatingData() {
+		try {
+			const api = this.addonCtx?.api;
+			if (!api) return {
+				availableBackends: null,
+				hardware: null
+			};
+			const caps = await api.platformProbe.getCapabilities.query();
+			if (!caps?.scores) return {
+				availableBackends: null,
+				hardware: null
+			};
+			return {
+				availableBackends: caps.scores.filter((s) => s.runtime === "python" && s.available).map((s) => s.backend),
+				hardware: caps.hardware ?? null
+			};
+		} catch {
+			return {
+				availableBackends: null,
+				hardware: null
+			};
+		}
+	}
 	async getSchema(engine) {
 		if (!engine || !engine.runtime) engine = await this.getSelectedEngine();
 		const format = engine.format;
 		const slots = buildSchemaSlots(format, this.modelsDir);
+		const { availableBackends, hardware } = await this.fetchProbeGatingData();
 		return {
-			availableEngines: this.getAvailableEnginesWithDevices(),
+			availableEngines: this.getAvailableEnginesWithDevices(availableBackends, hardware),
 			selectedEngine: { ...engine },
 			slots
 		};
 	}
 	async getAvailableEngines() {
-		return this.getAvailableEnginesWithDevices().map((e) => e.engine);
+		const { availableBackends, hardware } = await this.fetchProbeGatingData();
+		return this.getAvailableEnginesWithDevices(availableBackends, hardware).map((e) => e.engine);
 	}
-	getAvailableEnginesWithDevices() {
-		const engines = [];
-		if (process.platform === "darwin") engines.push({
+	/**
+	* Build the engine catalog filtered by probe data.
+	*
+	* When `availableBackends` is not null, only engines whose backend is
+	* reported as available by the platform-probe cap are included. This
+	* prevents the benchmark picker from offering (e.g.) CoreML on an Intel
+	* Linux host where the Python coremltools package is absent.
+	*
+	* When `hardware` is not null, the per-engine device list is narrowed to
+	* entries that are valid on this host's hardware (no Intel NPU → no 'npu'
+	* device for OpenVINO, no NVIDIA GPU → no 'cuda' for ONNX, etc.).
+	*
+	* When either argument is null (probe unreachable / cold-start), the full
+	* static catalog is returned unchanged — conservative fallback so the UI
+	* still renders all options rather than going blank.
+	*/
+	getAvailableEnginesWithDevices(availableBackends, hardware) {
+		const allEngines = [];
+		if (process.platform === "darwin") allEngines.push({
 			engine: {
 				runtime: "python",
 				backend: "coreml",
@@ -3920,7 +3966,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			devices: COREML_DEVICES,
 			defaultDevice: "all"
 		});
-		engines.push({
+		allEngines.push({
 			engine: {
 				runtime: "python",
 				backend: "openvino",
@@ -3929,7 +3975,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			devices: OPENVINO_DEVICES,
 			defaultDevice: "auto"
 		});
-		engines.push({
+		allEngines.push({
 			engine: {
 				runtime: "python",
 				backend: "onnx",
@@ -3938,7 +3984,19 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			devices: ONNX_PYTHON_DEVICES,
 			defaultDevice: "cpu"
 		});
-		return engines;
+		if (!availableBackends) return allEngines;
+		return allEngines.filter((e) => availableBackends.includes(e.engine.backend)).map((e) => {
+			if (!hardware) return e;
+			const filtered = filterDeviceOptionsByHardware(e.devices.map((d) => ({
+				value: d.id,
+				label: d.label
+			})), e.engine.backend, hardware);
+			const allowedIds = new Set(filtered.map((o) => o.value));
+			return {
+				...e,
+				devices: e.devices.filter((d) => allowedIds.has(d.id))
+			};
+		});
 	}
 	async getDefaultSteps(engine) {
 		return buildDefaultStepTree(engine.format);
@@ -4030,7 +4088,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				};
 			})
 		}));
-		const engines = this.getAvailableEnginesWithDevices();
+		const { availableBackends, hardware } = await this.fetchProbeGatingData();
+		const engines = this.getAvailableEnginesWithDevices(availableBackends, hardware);
 		const nodeBackends = [];
 		const pythonBackends = [];
 		for (const e of engines) if (e.engine.runtime === "node") nodeBackends.push({
@@ -5131,19 +5190,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	async loadEngine() {
 		const store = await this.readStore();
-		const runtime = store["engineRuntime"];
-		const backend = store["engineBackend"];
-		if (typeof runtime === "string" && typeof backend === "string" && runtime && backend) {
+		const storedRuntime = store["engineRuntime"];
+		const storedBackend = store["engineBackend"];
+		if (typeof storedBackend === "string" && storedBackend.length > 0) {
+			const backend = storedBackend;
 			const storedDevice = typeof store["engineDevice"] === "string" ? String(store["engineDevice"]) : "";
 			const detected = DetectionPipelineProvider.detectBestEngine();
-			if (runtime === "python" && !DetectionPipelineProvider.isPythonBackendAvailable(backend, this.executorOptions.pythonPath ?? "")) {
+			const migratedBackend = typeof storedRuntime === "string" && storedRuntime === "node" && backend === "cpu" ? "onnx" : backend;
+			if (!DetectionPipelineProvider.isPythonBackendAvailable(migratedBackend, this.executorOptions.pythonPath ?? "")) {
 				this.log.warn("Stored engine backend unavailable on this node — falling back to detected best", { meta: {
-					stored: `${runtime}/${backend}`,
-					fallback: `${detected.runtime}/${detected.backend}`
+					stored: migratedBackend,
+					fallback: `${detected.backend}`
 				} });
 				return detected;
 			}
-			const migratedBackend = runtime === "node" && backend === "cpu" ? "onnx" : backend;
 			const device = storedDevice || detected.device;
 			return {
 				runtime: "python",
@@ -5313,11 +5373,42 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return { success: true };
 	}
 	async reprobeEngine() {
-		const best = DetectionPipelineProvider.detectBestEngine();
-		const probedLabel = `${best.runtime}/${best.backend}/${best.device ?? "default"}`;
-		await this.writeStore({ probedBestEngine: probedLabel });
-		this.log.info("Re-probed engine", { meta: {
-			runtime: best.runtime,
+		const api = this.addonCtx?.api;
+		let best;
+		if (api) try {
+			const caps = await api.platformProbe.getCapabilities.query();
+			const bs = caps?.bestScore;
+			if (bs && bs.runtime === "python") {
+				const probeBackend = bs.backend;
+				const probeDevice = (() => {
+					const hw = caps.hardware;
+					if (probeBackend === "coreml") return hw?.npu?.type === "apple-ane" ? "ane" : "all";
+					if (probeBackend === "openvino") {
+						if (hw?.npu?.type === "intel-npu") return "npu";
+						if (hw?.gpu?.type === "intel") return "gpu";
+						return "auto";
+					}
+					if (probeBackend === "onnx") return hw?.gpu?.type === "nvidia" ? "cuda" : "cpu";
+					return "cpu";
+				})();
+				best = {
+					runtime: "python",
+					backend: probeBackend,
+					format: backendToFormat(probeBackend),
+					device: probeDevice
+				};
+			} else best = DetectionPipelineProvider.detectBestEngine();
+		} catch {
+			best = DetectionPipelineProvider.detectBestEngine();
+		}
+		else best = DetectionPipelineProvider.detectBestEngine();
+		const probedLabel = `${best.backend}/${best.device ?? "default"}`;
+		await this.writeStore({
+			probedBestEngine: probedLabel,
+			engineBackend: best.backend,
+			engineDevice: best.device ?? "cpu"
+		});
+		this.log.info("Re-probed engine — wrote back engineBackend + engineDevice", { meta: {
 			backend: best.backend,
 			device: best.device ?? null,
 			probedBestEngine: probedLabel
@@ -5735,10 +5826,12 @@ function shouldInstallOpenvino(hardware) {
 	const hasIntelNpu = hardware.npu?.type === "intel-npu";
 	return hasIntelGpu || hasIntelNpu;
 }
-var RUNTIMES = [{
-	value: "python",
-	label: "Python (CoreML / OpenVINO / ONNX Runtime)"
-}];
+/**
+* Full catalog of execution providers. The settings UI only shows the subset
+* reported as available by the platform-probe cap (`getGlobalSettings` gates
+* options by probe scores). Kept as the static universe so the static schema
+* (returned before a live ctx is available) still lists all fields.
+*/
 var BACKENDS_BY_RUNTIME = { python: [
 	{
 		value: "coreml",
@@ -5809,6 +5902,53 @@ var DEVICES_BY_BACKEND = {
 		label: "CPU"
 	}]
 };
+/**
+* Filter the per-backend device option list by what the platform probe
+* reports as available hardware on this host. Rules (derived from the
+* confirmed target model):
+*
+*  coreml:
+*    - `ane` only when `hardware.npu?.type === 'apple-ane'`
+*    - `gpu` and `all` always shown (CPU+GPU present on every Mac)
+*    - `cpu` always shown
+*
+*  openvino:
+*    - `npu` only when `hardware.npu?.type === 'intel-npu'`
+*    - `gpu` only when `hardware.gpu?.type === 'intel'`
+*    - `auto` and `cpu` always shown
+*
+*  onnx:
+*    - `cuda` only when `hardware.gpu?.type === 'nvidia'`
+*    - `coreml` only when `hardware.npu?.type === 'apple-ane'` (CoreML EP)
+*    - `cpu` always shown
+*
+* When `hardware` is null (probe unreachable), the full catalog is returned
+* unchanged so the UI still renders all options.
+*/
+function filterDeviceOptionsByHardware(options, backend, hardware) {
+	if (!hardware) return options;
+	const hasAppleAne = hardware.npu?.type === "apple-ane";
+	const hasIntelNpu = hardware.npu?.type === "intel-npu";
+	const hasIntelGpu = hardware.gpu?.type === "intel";
+	const hasNvidiaGpu = hardware.gpu?.type === "nvidia";
+	switch (backend) {
+		case "coreml": return options.filter((o) => {
+			if (o.value === "ane") return hasAppleAne;
+			return true;
+		});
+		case "openvino": return options.filter((o) => {
+			if (o.value === "npu") return hasIntelNpu;
+			if (o.value === "gpu") return hasIntelGpu;
+			return true;
+		});
+		case "onnx": return options.filter((o) => {
+			if (o.value === "cuda") return hasNvidiaGpu;
+			if (o.value === "coreml") return hasAppleAne;
+			return true;
+		});
+		default: return options;
+	}
+}
 var BACKEND_TO_FORMAT = {
 	cpu: "onnx",
 	coreml: "coreml",
@@ -5940,13 +6080,13 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 			title: "Object detection",
 			tab: "engine",
 			order: 0,
-			description: "Vision-detection backend (object detection, face detection, plate OCR). Chain: runtime → backend → hardware. Backend options depend on runtime; hardware options depend on backend. All three restart the addon on change.",
+			description: "Vision-detection execution provider (object detection, face detection, plate OCR). Inference always runs via the embedded Python runtime. Provider and hardware options are gated by what the platform probe reports as available on this host. Changes restart the addon.",
 			fields: [
 				this.field({
 					type: "text",
 					key: "probedBestEngine",
 					label: "Probed best",
-					description: "Auto-detected best engine for this host (format: runtime/backend/device). Click the refresh icon to re-run the probe — the detected values get written back into the three fields below.",
+					description: "Auto-detected best engine for this host (format: provider/device, e.g. \"openvino/npu\"). Click the refresh icon to re-run the probe — the detected provider and hardware device are written back into the two fields below, overwriting any manual override.",
 					readonlyField: true,
 					default: "",
 					actions: [{
@@ -5955,19 +6095,10 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 						tooltip: "Re-probe engine"
 					}]
 				}),
-				this.field({
-					type: "select",
-					key: "engineRuntime",
-					label: "Runtime",
-					options: [...RUNTIMES],
-					default: DEFAULT_CONFIG.engineRuntime,
-					immediate: true,
-					requiresRestart: true
-				}),
 				this.field({
 					type: "select",
 					key: "engineBackend",
-					label: "Backend",
+					label: "Execution provider",
 					options: [...BACKENDS_BY_RUNTIME.python],
 					default: DEFAULT_CONFIG.engineBackend,
 					immediate: true,
@@ -6105,14 +6236,16 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 			...overlay
 		} : stored;
 		const runtime = "python";
-		const availableBackends = await this.resolveAvailableBackends(ctx, runtime);
+		const probeResult = await this.resolveProbeData(ctx, runtime);
+		const availableBackends = probeResult.availableBackends;
+		const hardware = probeResult.hardware;
 		const runtimeBackends = availableBackends.length > 0 ? BACKENDS_BY_RUNTIME[runtime].filter((b) => availableBackends.includes(b.value)) : BACKENDS_BY_RUNTIME[runtime];
 		const storedBackend = typeof merged.engineBackend === "string" ? merged.engineBackend : "";
-		const backend = runtimeBackends.find((b) => b.value === storedBackend)?.value ?? runtimeBackends[0]?.value ?? "coreml";
-		const deviceOptions = DEVICES_BY_BACKEND[backend] ?? [{
+		const backend = runtimeBackends.find((b) => b.value === storedBackend)?.value ?? probeResult.bestBackend ?? runtimeBackends[0]?.value ?? "coreml";
+		const deviceOptions = filterDeviceOptionsByHardware(DEVICES_BY_BACKEND[backend] ?? [{
 			value: "cpu",
 			label: "CPU"
-		}];
+		}], backend, hardware);
 		const storedDevice = typeof merged.engineDevice === "string" ? merged.engineDevice : "";
 		const device = deviceOptions.find((d) => d.value === storedDevice)?.value ?? deviceOptions[0]?.value ?? "cpu";
 		const raw = {
@@ -6162,28 +6295,47 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		}, raw);
 	}
 	/**
-	* Ask the platform-probe cap which backends are actually installable
-	* on this node (checks for `openvino`, `coremltools`, `onnxruntime`
-	* Python modules + hardware presence). Returns a subset of the static
-	* catalog; an empty list signals the probe wasn't available so the
-	* caller should fall back to the full catalog rather than hiding
-	* every option.
+	* Fetch the platform-probe capabilities and return:
+	* - `availableBackends`: backends the probe reports as available for `runtime`
+	*   (empty → caller falls back to full catalog).
+	* - `hardware`: the probed hardware info (null when probe not reachable).
+	* - `bestBackend`: the backend from the probe's `bestScore` (null when unavailable).
+	*
+	* A single probe call is made so both backend AND device gating use the
+	* same snapshot without doubling the cap round-trip.
 	*/
-	async resolveAvailableBackends(ctx, runtime) {
+	async resolveProbeData(ctx, runtime) {
 		try {
 			const api = ctx?.api;
-			if (!api) return [];
+			if (!api) return {
+				availableBackends: [],
+				hardware: null,
+				bestBackend: null
+			};
 			const caps = await api.platformProbe.getCapabilities.query();
-			if (!caps?.scores) return [];
+			if (!caps?.scores) return {
+				availableBackends: [],
+				hardware: null,
+				bestBackend: null
+			};
 			const out = /* @__PURE__ */ new Set();
 			for (const s of caps.scores) {
 				if (s.runtime !== runtime) continue;
 				if (!s.available) continue;
 				out.add(s.backend);
 			}
-			return [...out];
+			const bestBackend = caps.bestScore?.runtime === runtime ? caps.bestScore.backend ?? null : null;
+			return {
+				availableBackends: [...out],
+				hardware: caps.hardware ?? null,
+				bestBackend
+			};
 		} catch {
-			return [];
+			return {
+				availableBackends: [],
+				hardware: null,
+				bestBackend: null
+			};
 		}
 	}
 	/**
@@ -6408,6 +6560,7 @@ exports.ALL_STEPS = ALL_STEPS;
 exports.DetectionPipelineProvider = DetectionPipelineProvider;
 exports.backendToFormat = backendToFormat;
 exports.default = DetectionPipelineAddon;
+exports.filterDeviceOptionsByHardware = filterDeviceOptionsByHardware;
 exports.getDefaultModelForFormat = getDefaultModelForFormat;
 exports.getStepDefinition = getStepDefinition;
 exports.shouldInstallOpenvino = shouldInstallOpenvino;