Add getChip() NPU chip detection across Kotlin, Flutter, and React Native SDKs

Adds public getChip() API that detects Qualcomm NPU chipsets (Snapdragon 8 Elite / 8 Elite Gen 5)
and returns an identifier used to construct dynamic HuggingFace download URLs for Genie NPU models.
Android app ModelList now uses getChip() for dynamic model registration instead of hardcoded URLs.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Siddhesh2377

examples/android/RunAnywhereAI/app/src/main/java/com/runanywhere/runanywhereai/data/ModelList.kt

@@ -11,6 +11,7 @@ import com.runanywhere.sdk.public.extensions.LoraAdapterCatalogEntry
 import com.runanywhere.sdk.public.extensions.ModelCompanionFile
 import com.runanywhere.sdk.public.extensions.Models.ModelCategory
 import com.runanywhere.sdk.public.extensions.Models.ModelFileDescriptor
+import com.runanywhere.sdk.public.extensions.getChip
 import com.runanywhere.sdk.public.extensions.registerLoraAdapter
 import com.runanywhere.sdk.public.extensions.registerModel
 import com.runanywhere.sdk.public.extensions.registerMultiFileModel
@@ -126,19 +127,21 @@ object ModelList {
         ),
     )
 
-    // Genie NPU Models (Qualcomm Snapdragon 8 Gen 2+)
-    // Pre-compiled QNN context binaries for Qualcomm Genie SDK.
-    // Compiled via: python -m qai_hub_models.models.<model>.export --chipset qualcomm-snapdragon-8-elite
-    private val genieModels = listOf(
-        AppModel(id = "qwen2_5-7b-instruct-genie", name = "Qwen 2.5 7B (NPU)",
-            url = "https://huggingface.co/runanywhere/genie-npu-models/resolve/main/qwen2.5-7b-instruct-genie-w8a16.tar.gz",
-            framework = InferenceFramework.GENIE, category = ModelCategory.LANGUAGE,
-            memoryRequirement = 5_000_000_000),
-        AppModel(id = "llama-3.2-1b-instruct-genie", name = "Llama 3.2 1B (NPU)",
-            url = "https://huggingface.co/runanywhere/genie-npu-models/resolve/main/llama-3.2-1b-instruct-genie-w4.tar.gz",
-            framework = InferenceFramework.GENIE, category = ModelCategory.LANGUAGE,
-            memoryRequirement = 1_500_000_000),
-    )
+    // Genie NPU Models — URLs are built dynamically based on detected chipset.
+    // getChip() returns the NPUChip for this device, or null if unsupported.
+    private fun genieModels(): List<AppModel> {
+        val chip = RunAnywhere.getChip() ?: return emptyList()
+        return listOf(
+            AppModel(
+                id = "qwen-npu-${chip.identifier}",
+                name = "Qwen3 4B (NPU - ${chip.displayName})",
+                url = chip.downloadUrl("qwen"),
+                framework = InferenceFramework.GENIE,
+                category = ModelCategory.LANGUAGE,
+                memoryRequirement = 2_800_000_000,
+            ),
+        )
+    }
 
     // VLM
     private val vlmModels = listOf(
@@ -176,7 +179,7 @@ object ModelList {
 
         val allModels = listOf(
             "LLM/STT/TTS" to (llmModels + sttModels + ttsModels),
-            "Genie NPU" to genieModels,
+            "Genie NPU" to genieModels(),
             "Embedding" to embeddingModels,
             "VLM" to vlmModels,
         )

sdk/runanywhere-flutter/packages/runanywhere/android/src/main/kotlin/ai/runanywhere/sdk/RunAnywherePlugin.kt

@@ -48,6 +48,9 @@ class RunAnywherePlugin : FlutterPlugin, MethodCallHandler {
             "getCommonsVersion" -> {
                 result.success(COMMONS_VERSION)
             }
+            "getSocModel" -> {
+                result.success(getSocModel())
+            }
             else -> {
                 result.notImplemented()
             }
@@ -57,4 +60,18 @@ class RunAnywherePlugin : FlutterPlugin, MethodCallHandler {
     override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
         channel.setMethodCallHandler(null)
     }
+
+    /**
+     * Get the SoC model string for NPU chip detection.
+     * Uses Build.SOC_MODEL (API 31+) with Build.HARDWARE fallback.
+     */
+    private fun getSocModel(): String {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val socModel = Build.SOC_MODEL
+            if (!socModel.isNullOrEmpty() && socModel != "unknown") {
+                return socModel
+            }
+        }
+        return Build.HARDWARE ?: ""
+    }
 }

sdk/runanywhere-flutter/packages/runanywhere/lib/core/types/npu_chip.dart

@@ -0,0 +1,42 @@
+/// Supported NPU chipsets for on-device Genie model inference.
+///
+/// Each chip has an [identifier] used to construct dynamic download URLs
+/// for chipset-specific NPU model binaries.
+///
+/// Example:
+/// ```dart
+/// final chip = RunAnywhere.getChip();
+/// if (chip != null) {
+///   final url = chip.downloadUrl('qwen');
+///   // → https://huggingface.co/Void2377/npu-models/resolve/main/qwen-gen1.zip?download=true
+/// }
+/// ```
+enum NPUChip {
+  snapdragon8Elite('gen1', 'Snapdragon 8 Elite', 'SM8750'),
+  snapdragon8EliteGen5('gen2', 'Snapdragon 8 Elite Gen 5', 'SM8850');
+
+  final String identifier;
+  final String displayName;
+  final String socModel;
+
+  const NPUChip(this.identifier, this.displayName, this.socModel);
+
+  /// Base URL for NPU model downloads on HuggingFace.
+  static const baseUrl =
+      'https://huggingface.co/Void2377/npu-models/resolve/main/';
+
+  /// Build a HuggingFace download URL for this chip.
+  /// [modelName] is the model prefix (e.g. "qwen") → produces "qwen-gen1.zip"
+  String downloadUrl(String modelName) =>
+      '$baseUrl$modelName-$identifier.zip?download=true';
+
+  /// Match an NPU chip from a SoC model string (e.g. "SM8750").
+  /// Returns null if the SoC is not a supported NPU chipset.
+  static NPUChip? fromSocModel(String socModel) {
+    final upper = socModel.toUpperCase();
+    for (final chip in NPUChip.values) {
+      if (upper.contains(chip.socModel)) return chip;
+    }
+    return null;
+  }
+}

sdk/runanywhere-flutter/packages/runanywhere/lib/public/extensions/runanywhere_device.dart

@@ -0,0 +1,45 @@
+/// RunAnywhere + Device
+///
+/// Public API for NPU chip detection.
+/// Android only — returns null on iOS and other platforms.
+library runanywhere_device;
+
+import 'dart:io' show Platform;
+
+import 'package:flutter/services.dart';
+import 'package:runanywhere/core/types/npu_chip.dart';
+import 'package:runanywhere/public/runanywhere.dart';
+
+// =============================================================================
+// NPU Chip Detection
+// =============================================================================
+
+/// Extension methods for NPU chip detection
+extension RunAnywhereDevice on RunAnywhere {
+  static final _channel = MethodChannel('runanywhere');
+
+  /// Detect the device's NPU chipset for Genie model compatibility.
+  ///
+  /// Returns the [NPUChip] if the device has a supported Qualcomm SoC,
+  /// or null if the device is not Android or does not support NPU inference.
+  ///
+  /// Example:
+  /// ```dart
+  /// final chip = RunAnywhereDevice.getChip();
+  /// if (chip != null) {
+  ///   final url = chip.downloadUrl('qwen');
+  ///   RunAnywhere.registerModel(id: 'qwen-npu', name: 'Qwen NPU', url: url, ...);
+  /// }
+  /// ```
+  static Future<NPUChip?> getChip() async {
+    if (!Platform.isAndroid) return null;
+
+    try {
+      final socModel = await _channel.invokeMethod<String>('getSocModel');
+      if (socModel == null || socModel.isEmpty) return null;
+      return NPUChip.fromSocModel(socModel);
+    } on PlatformException {
+      return null;
+    }
+  }
+}

sdk/runanywhere-flutter/packages/runanywhere/lib/runanywhere.dart

@@ -24,6 +24,8 @@ export 'public/configuration/sdk_environment.dart';
 export 'public/errors/errors.dart';
 export 'public/events/event_bus.dart';
 export 'public/events/sdk_event.dart';
+export 'core/types/npu_chip.dart';
+export 'public/extensions/runanywhere_device.dart';
 export 'public/extensions/runanywhere_frameworks.dart';
 export 'public/extensions/runanywhere_logging.dart';
 export 'public/extensions/runanywhere_storage.dart';

sdk/runanywhere-kotlin/src/androidMain/kotlin/com/runanywhere/sdk/public/extensions/RunAnywhere+Device.kt

@@ -0,0 +1,59 @@
+package com.runanywhere.sdk.public.extensions
+
+import android.os.Build
+import com.runanywhere.sdk.core.types.NPUChip
+import com.runanywhere.sdk.foundation.SDKLogger
+import com.runanywhere.sdk.public.RunAnywhere
+
+/**
+ * Android implementation of NPU chip detection.
+ *
+ * Detection strategy (ordered):
+ * 1. [Build.SOC_MODEL] (API 31+) — e.g. "SM8750"
+ * 2. [Build.HARDWARE] — fallback codename
+ * 3. /proc/cpuinfo Hardware line — last resort
+ */
+actual fun RunAnywhere.getChip(): NPUChip? {
+    val logger = SDKLogger("NPUChip")
+
+    // 1. Try Build.SOC_MODEL (API 31+)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        val socModel = Build.SOC_MODEL
+        if (!socModel.isNullOrEmpty() && socModel != "unknown") {
+            val chip = NPUChip.fromSocModel(socModel)
+            if (chip != null) {
+                logger.info("Detected NPU chip: ${chip.displayName} (SOC_MODEL=$socModel)")
+                return chip
+            }
+        }
+    }
+
+    // 2. Try Build.HARDWARE
+    val hardware = Build.HARDWARE
+    if (!hardware.isNullOrEmpty() && hardware != "unknown") {
+        val chip = NPUChip.fromSocModel(hardware)
+        if (chip != null) {
+            logger.info("Detected NPU chip: ${chip.displayName} (HARDWARE=$hardware)")
+            return chip
+        }
+    }
+
+    // 3. Try /proc/cpuinfo
+    try {
+        val cpuInfo = java.io.File("/proc/cpuinfo").readText()
+        val hardwareLine = cpuInfo.lines().find { it.startsWith("Hardware", ignoreCase = true) }
+        if (hardwareLine != null) {
+            val cpuHardware = hardwareLine.substringAfter(":").trim()
+            val chip = NPUChip.fromSocModel(cpuHardware)
+            if (chip != null) {
+                logger.info("Detected NPU chip: ${chip.displayName} (cpuinfo=$cpuHardware)")
+                return chip
+            }
+        }
+    } catch (_: Exception) {
+        // Fall through
+    }
+
+    logger.debug("No supported NPU chip detected")
+    return null
+}

sdk/runanywhere-kotlin/src/commonMain/kotlin/com/runanywhere/sdk/core/types/NPUChip.kt

@@ -0,0 +1,44 @@
+package com.runanywhere.sdk.core.types
+
+/**
+ * Supported NPU chipsets for on-device Genie model inference.
+ *
+ * Each chip has an [identifier] used to construct dynamic download URLs
+ * for chipset-specific NPU model binaries.
+ *
+ * Example URL construction:
+ * ```
+ * val chip = RunAnywhere.getChip()
+ * val url = "${NPUChip.BASE_URL}qwen-${chip.identifier}.zip?download=true"
+ * ```
+ */
+enum class NPUChip(
+    val identifier: String,
+    val displayName: String,
+    val socModel: String,
+) {
+    SNAPDRAGON_8_ELITE("gen1", "Snapdragon 8 Elite", "SM8750"),
+    SNAPDRAGON_8_ELITE_GEN5("gen2", "Snapdragon 8 Elite Gen 5", "SM8850"),
+    ;
+
+    /**
+     * Build a HuggingFace download URL for this chip.
+     * @param modelName Model prefix (e.g. "qwen") → produces "qwen-gen1.zip"
+     */
+    fun downloadUrl(modelName: String): String =
+        "${BASE_URL}${modelName}-${identifier}.zip?download=true"
+
+    companion object {
+        /** Base URL for NPU model downloads on HuggingFace. */
+        const val BASE_URL = "https://huggingface.co/Void2377/npu-models/resolve/main/"
+
+        /**
+         * Match an NPU chip from a SoC model string (e.g. "SM8750").
+         * Returns null if the SoC is not a supported NPU chipset.
+         */
+        fun fromSocModel(socModel: String): NPUChip? {
+            val upper = socModel.uppercase()
+            return entries.firstOrNull { upper.contains(it.socModel) }
+        }
+    }
+}

sdk/runanywhere-kotlin/src/commonMain/kotlin/com/runanywhere/sdk/public/extensions/RunAnywhere+Device.kt

@@ -0,0 +1,21 @@
+package com.runanywhere.sdk.public.extensions
+
+import com.runanywhere.sdk.core.types.NPUChip
+import com.runanywhere.sdk.public.RunAnywhere
+
+/**
+ * Detect the device's NPU chipset for Genie model compatibility.
+ *
+ * Returns the [NPUChip] if the device has a supported Qualcomm SoC,
+ * or null if the device does not support NPU inference.
+ *
+ * Use [NPUChip.identifier] to construct chipset-specific download URLs:
+ * ```kotlin
+ * val chip = RunAnywhere.getChip()
+ * if (chip != null) {
+ *     val url = "https://example.com/models/qwen-${chip.identifier}.zip"
+ *     RunAnywhere.registerModel(id = "qwen-npu", name = "Qwen NPU", url = url, ...)
+ * }
+ * ```
+ */
+expect fun RunAnywhere.getChip(): NPUChip?

sdk/runanywhere-kotlin/src/jvmMain/kotlin/com/runanywhere/sdk/public/extensions/RunAnywhere+Device.kt

@@ -0,0 +1,9 @@
+package com.runanywhere.sdk.public.extensions
+
+import com.runanywhere.sdk.core.types.NPUChip
+import com.runanywhere.sdk.public.RunAnywhere
+
+/**
+ * JVM stub — NPU chip detection is not applicable on desktop.
+ */
+actual fun RunAnywhere.getChip(): NPUChip? = null

sdk/runanywhere-react-native/packages/core/src/Public/Extensions/RunAnywhere+Device.ts

@@ -0,0 +1,59 @@
+/**
+ * RunAnywhere+Device.ts
+ *
+ * NPU chip detection extension. Android only.
+ * Returns null on iOS and other platforms.
+ */
+
+import { Platform } from 'react-native';
+import { requireDeviceInfoModule } from '../../native/NativeRunAnywhereCore';
+import { npuChipFromSocModel } from '../../types/NPUChip';
+import { SDKLogger } from '../../Foundation/Logging/Logger/SDKLogger';
+import type { NPUChip } from '../../types/NPUChip';
+
+const logger = new SDKLogger('RunAnywhere.Device');
+
+/**
+ * Detect the device's NPU chipset for Genie model compatibility.
+ *
+ * Returns the NPUChip if the device has a supported Qualcomm SoC,
+ * or null if the device is not Android or does not support NPU inference.
+ *
+ * @example
+ * ```typescript
+ * const chip = await getChip();
+ * if (chip) {
+ *   const url = getNPUDownloadUrl(chip, 'qwen');
+ *   await RunAnywhere.registerModel({ id: 'qwen-npu', name: 'Qwen NPU', url, ... });
+ * }
+ * ```
+ */
+export async function getChip(): Promise<NPUChip | null> {
+  if (Platform.OS !== 'android') {
+    return null;
+  }
+
+  try {
+    const deviceInfo = requireDeviceInfoModule();
+    const chipName = await deviceInfo.getChipName();
+
+    if (!chipName || chipName === 'Unknown') {
+      logger.debug('No chip name available from device info');
+      return null;
+    }
+
+    const chip = npuChipFromSocModel(chipName);
+    if (chip) {
+      logger.info(
+        `Detected NPU chip: ${chip.displayName} (chipName=${chipName})`
+      );
+    } else {
+      logger.debug(`No supported NPU chip for: ${chipName}`);
+    }
+
+    return chip ?? null;
+  } catch (error) {
+    logger.debug('Failed to detect NPU chip');
+    return null;
+  }
+}