Gate LiteRT-LM backend by SoC (NPU on verified chips, GPU elsewhere)

Runtime/AgentCore/AgentBuilder.cs

@@ -142,9 +142,12 @@ namespace OnDeviceAgent.AgentCore
                 TurnReminder = TurnReminder,
             };
     #if UNITY_ANDROID && !UNITY_EDITOR
-            // Galaxy Z Fold 7 (SM8750/v79) Hexagon NPU — verified working (~25 tok/s, text + multimodal, streaming).
-            // Transport falls back to CPU if NPU init fails. (GPU/CPU need the plain model in LiteRtModelProvisioner.)
-            IAgentTransport transport = new AndroidLlmTransport(dispatcher, "NPU", Log);
+            // Pick NPU only on SoCs verified to run the QNN export (Fold 7 / SM8750); every other device uses GPU
+            // (with CPU fallback in the transport). The model file is matched to this same decision in the
+            // provisioner — keep them in sync, since the wrong-SoC NPU export aborts nativeCreateEngine natively.
+            // UseNpu is read here, on the Unity main thread, so its JNI SoC query runs safely.
+            var llmBackend = LiteRtModelProvisioner.UseNpu ? "NPU" : "GPU";
+            IAgentTransport transport = new AndroidLlmTransport(dispatcher, llmBackend, Log);
     #else
             IAgentTransport transport = new OllamaTransport(Endpoint, Model, options.AgentName, Log);
     #endif

Runtime/AgentCore/Rag/KnowledgeRagComponent.cs

@@ -65,7 +65,8 @@ namespace OnDeviceAgent.AgentCore
 
     #if UNITY_ANDROID && !UNITY_EDITOR
             // Route RAG's LLM through the shared LiteRT-LM singleton - Ollama HTTP doesn't exist on-device and reusing avoids a second model load.
-            var androidTransport = new AndroidLlmTransport(dispatcher, "GPU", Debug.Log);
+            // Match the main transport's SoC-gated backend so this doesn't request a conflicting one for the shared engine.
+            var androidTransport = new AndroidLlmTransport(dispatcher, LiteRtModelProvisioner.UseNpu ? "NPU" : "GPU", Debug.Log);
             IChatLlm ragLlm = new AndroidChatLlm(
                 (sys, prompt, ct) => androidTransport.RunAsync(sys, prompt, null, null, ct), model);
             m_Rag = new LightRagKnowledgeService(dbWorkingDir, ragLlm, embedder, dispatcher,

Runtime/AgentCore/Runtime/LiteRtModelProvisioner.cs

@@ -13,9 +13,22 @@ namespace OnDeviceAgent.AgentCore
 {
 public static class LiteRtModelProvisioner
 {
-    // Galaxy Z Fold 7 (SM8750 / Hexagon v79) NPU export — verified working (~25 tok/s, multimodal). The plain
-    // "gemma-4-E2B-it.litertlm" is the GPU/CPU variant (the NPU QNN export only runs on NPU).
-    public const string ModelFileName = "gemma-4-E2B-it_qualcomm_sm8750.litertlm";
+    // SoC-specific QNN export for the Hexagon NPU (Galaxy Z Fold 7, SM8750/v79 — verified ~25 tok/s, multimodal).
+    // It ONLY runs on its target NPU; loading it elsewhere aborts nativeCreateEngine (native SIGABRT, uncatchable).
+    public const string NpuModelFileName = "gemma-4-E2B-it_qualcomm_sm8750.litertlm";
+    // GPU/CPU variant — runs on any device.
+    public const string GpuModelFileName = "gemma-4-E2B-it.litertlm";
+
+    // SoC models whose NPU is verified to run NpuModelFileName. Anything else (incl. unknown / pre-API-31) uses GPU.
+    static readonly string[] s_NpuCapableSocs = { "SM8750" };
+
+    // Decided once from the device SoC. True -> NPU model + "NPU" backend; false -> GPU model + "GPU" backend.
+    // First access MUST be on the Unity main thread (JNI) — AgentBuilder reads it when building the transport.
+    static bool? s_UseNpu;
+    public static bool UseNpu => s_UseNpu ??= DetectNpuCapable();
+
+    // The model file to provision for this device, picked from the SoC capability.
+    public static string ModelFileName => UseNpu ? NpuModelFileName : GpuModelFileName;
 
     // Hugging Face source for the runtime download (overridable before the first engine init).
     public static string HfRepo = "litert-community/gemma-4-E2B-it-litert-lm";
@@ -28,10 +41,29 @@ public static class LiteRtModelProvisioner
     public static Action<float> OnDownloadProgress;
 
     // Where `adb push` lands the file during development.
-    public const string PushSourcePath = "/data/local/tmp/" + ModelFileName;
+    public static string PushSourcePath => "/data/local/tmp/" + ModelFileName;
 
     const string SubDir = "LiteRtModels";
 
+    static bool DetectNpuCapable()
+    {
+        try
+        {
+            using var build = new UnityEngine.AndroidJavaClass("android.os.Build");
+            // Build.SOC_MODEL exists on API 31+; "" / exception on older OS falls through to the GPU path.
+            var soc = (build.GetStatic<string>("SOC_MODEL") ?? "").ToUpperInvariant();
+            var npu = false;
+            foreach (var s in s_NpuCapableSocs)
+                if (soc.Contains(s)) { npu = true; break; }
+            UnityEngine.Debug.Log($"[LiteRtModelProvisioner] SOC_MODEL='{soc}' -> {(npu ? "NPU" : "GPU")} path");
+            return npu;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
     // Returns the absolute path to a model file the JNI engine can open, provisioning it on first use.
     // `persistentDataPath` must be captured by the caller on the Unity main thread.
     public static async Task<string> EnsureModelAsync(string persistentDataPath, Action<string> log = null, CancellationToken ct = default)