@dr33m/react-native-litert-lm 0.5.1 → 0.5.3

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM.kt

@@ -163,9 +163,9 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                 try {
                     // Early GPU hardware check: probe for OpenCL library.
                     // LiteRT-LM's GPU delegate requires OpenCL, which is absent on
-                    // most Samsung/Qualcomm devices. Log a warning — fallback will
-                    // handle it gracefully below.
-                    if (backend == Backend.GPU) {
+                    // most Samsung/Qualcomm devices. Probe once and cache the result —
+                    // needed for both GPU main backend and multimodal vision backend.
+                    if (openCLAvailable == null) {
                         val hasOpenCL = openCLAvailable ?: run {
                             val result = try {
                                 System.loadLibrary("OpenCL")
@@ -244,17 +244,38 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                         }
                     }
 
-                    // Map our Backend enum to LiteRT-LM Backend sealed class
+                    // Map our Backend enum to LiteRT-LM Backend sealed class.
+                    // If hardware is unavailable, skip directly to CPU to avoid native
+                    // crashes (SIGSEGV) that Kotlin's try/catch cannot intercept.
                     val lmBackend = when (backend) {
-                        Backend.GPU -> com.google.ai.edge.litertlm.Backend.GPU()
+                        Backend.GPU -> {
+                            val hasOpenCL = openCLAvailable ?: false
+                            if (hasOpenCL) {
+                                com.google.ai.edge.litertlm.Backend.GPU()
+                            } else {
+                                Log.w(TAG, "GPU requested but OpenCL unavailable — using CPU directly")
+                                backend = Backend.CPU
+                                com.google.ai.edge.litertlm.Backend.CPU()
+                            }
+                        }
                         Backend.NPU -> {
-                            Log.i(TAG, "NPU backend requested - requires hardware support")
-                            com.google.ai.edge.litertlm.Backend.NPU()
+                            val nativeLibDir = LiteRTLMInitProvider.applicationContext?.applicationInfo?.nativeLibraryDir
+                            Log.i(TAG, "NPU backend requested - nativeLibraryDir=$nativeLibDir")
+                            if (nativeLibDir != null) {
+                                com.google.ai.edge.litertlm.Backend.NPU(nativeLibraryDir = nativeLibDir)
+                            } else {
+                                Log.w(TAG, "NPU requested but nativeLibraryDir unavailable — using CPU directly")
+                                backend = Backend.CPU
+                                com.google.ai.edge.litertlm.Backend.CPU()
+                            }
                         }
                         else -> com.google.ai.edge.litertlm.Backend.CPU()
                     }
 
-                    val lmVisionBackend = if (isMultimodal) com.google.ai.edge.litertlm.Backend.GPU() else null
+                    val lmVisionBackend = if (isMultimodal) {
+                        if (openCLAvailable == true) com.google.ai.edge.litertlm.Backend.GPU()
+                        else com.google.ai.edge.litertlm.Backend.CPU()
+                    } else null
                     val lmAudioBackend = if (isMultimodal) com.google.ai.edge.litertlm.Backend.CPU() else null
     
                     Log.i(TAG, "Backend config: main=$lmBackend, vision=$lmVisionBackend, audio=$lmAudioBackend, multimodal=$isMultimodal")
@@ -558,6 +579,18 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         )
     }
 
+    override fun checkModelCapabilities(modelPath: String): ModelCapabilities {
+        var supportsSpeculativeDecoding = false
+        try {
+            com.google.ai.edge.litertlm.Capabilities(modelPath).use {
+                supportsSpeculativeDecoding = it.hasSpeculativeDecodingSupport()
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "checkModelCapabilities: failed to query capabilities: ${e.message}")
+        }
+        return ModelCapabilities(supportsSpeculativeDecoding = supportsSpeculativeDecoding)
+    }
+
     override fun getActiveBackend(): Backend = backend
 
     override fun stopGeneration() {

package/app.plugin.js

@@ -2,10 +2,11 @@
  * Expo config plugin for react-native-litert-lm.
  *
  * Ensures correct build settings for the LiteRT-LM native module:
- * - Android: minSdkVersion 26
+ * - Android: minSdkVersion 26, Kotlin 2.3.0 (required by litertlm-android AAR)
  */
 const {
   withGradleProperties,
+  withProjectBuildGradle,
 } = require('@expo/config-plugins');
 
 function withLiteRTLM(config) {
@@ -28,6 +29,24 @@ function withLiteRTLM(config) {
     return config;
   });
 
+  // Android: Pin Kotlin Gradle plugin to 2.3.0
+  // The litertlm-android AAR uses Kotlin 2.3.0 metadata which cannot be read
+  // by older compilers. This forces the project-level Kotlin plugin to 2.3.0.
+  config = withProjectBuildGradle(config, (config) => {
+    if (config.modResults.language === 'groovy') {
+      const contents = config.modResults.contents;
+
+      if (!contents.includes("kotlin-gradle-plugin:2.3.0")) {
+        config.modResults.contents = contents.replace(
+          "classpath('org.jetbrains.kotlin:kotlin-gradle-plugin')",
+          "classpath('org.jetbrains.kotlin:kotlin-gradle-plugin:2.3.0')"
+        );
+      }
+    }
+
+    return config;
+  });
+
   return config;
 }
 

package/ios/HybridLiteRTLM.swift

@@ -142,6 +142,13 @@ public class HybridLiteRTLM: HybridLiteRTLMSpec_base, HybridLiteRTLMSpec_protoco
         )
     }
     
+    public func checkModelCapabilities(modelPath: String) throws -> ModelCapabilities {
+        // iOS LiteRT-LM C API doesn't expose a Capabilities class like Android.
+        // Return safe defaults — speculative decoding support can be detected
+        // at engine init time on iOS.
+        return ModelCapabilities(supportsSpeculativeDecoding: false)
+    }
+
     public func getActiveBackend() throws -> Backend {
         return backend
     }

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 import type { Backend } from "./specs/LiteRTLM.nitro";
-export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, MemoryUsage, 
+export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, MemoryUsage, ModelCapabilities, 
 /** New in v0.5: pass to execute() instead of individual send methods */
 MultimodalPart, PartType, 
 /** Tool calling types */

package/lib/specs/LiteRTLM.nitro.d.ts

@@ -207,6 +207,14 @@ export interface MemoryUsage {
     /** Whether the system considers memory low */
     isLowMemory: boolean;
 }
+/**
+ * Model capability flags queried from the model file at runtime.
+ * Uses the LiteRT-LM Capabilities API to inspect compiled model metadata.
+ */
+export interface ModelCapabilities {
+    /** Whether the model binary supports multi-token prediction (speculative decoding). */
+    supportsSpeculativeDecoding: boolean;
+}
 /**
  * LiteRT-LM: High-performance LLM inference engine.
  * Supports Gemma 4, Gemma 3n, Phi-4, Qwen, and other .litertlm models.
@@ -356,6 +364,13 @@ export interface LiteRTLM extends HybridObject<{
      * No-op if nothing is generating.
      */
     stopGeneration(): void;
+    /**
+     * Query model capabilities from the compiled model file.
+     * Does NOT require loadModel() — reads metadata directly from disk.
+     * @param modelPath Absolute path to the .litertlm model file.
+     * @returns Capabilities flags (e.g. speculative decoding support).
+     */
+    checkModelCapabilities(modelPath: string): ModelCapabilities;
     /**
      * Release all native resources.
      * Call this when done with the LLM instance.

package/nitrogen/generated/android/c++/JBackend.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ enum "Backend" and the the Kotlin enum "Backend".
+   * The C++ JNI bridge between the C++ enum "Backend" and the Kotlin enum "Backend".
    */
   struct JBackend final: public jni::JavaClass<JBackend> {
   public:

package/nitrogen/generated/android/c++/JExecuteResult.hpp

@@ -20,7 +20,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "ExecuteResult" and the the Kotlin data class "ExecuteResult".
+   * The C++ JNI bridge between the C++ struct "ExecuteResult" and the Kotlin data class "ExecuteResult".
    */
   struct JExecuteResult final: public jni::JavaClass<JExecuteResult> {
   public:

package/nitrogen/generated/android/c++/JGenerationStats.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "GenerationStats" and the the Kotlin data class "GenerationStats".
+   * The C++ JNI bridge between the C++ struct "GenerationStats" and the Kotlin data class "GenerationStats".
    */
   struct JGenerationStats final: public jni::JavaClass<JGenerationStats> {
   public:

package/nitrogen/generated/android/c++/JHybridLiteRTLMSpec.cpp

@@ -21,6 +21,8 @@ namespace margelo::nitro::litertlm { struct GenerationStats; }
 namespace margelo::nitro::litertlm { struct MemoryUsage; }
 // Forward declaration of `Backend` to properly resolve imports.
 namespace margelo::nitro::litertlm { enum class Backend; }
+// Forward declaration of `ModelCapabilities` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct ModelCapabilities; }
 // Forward declaration of `LLMConfig` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct LLMConfig; }
 // Forward declaration of `ToolDefinition` to properly resolve imports.
@@ -51,6 +53,8 @@ namespace margelo::nitro::litertlm { struct ToolResponse; }
 #include "JMemoryUsage.hpp"
 #include "Backend.hpp"
 #include "JBackend.hpp"
+#include "ModelCapabilities.hpp"
+#include "JModelCapabilities.hpp"
 #include "LLMConfig.hpp"
 #include <optional>
 #include "JLLMConfig.hpp"
@@ -363,6 +367,11 @@ namespace margelo::nitro::litertlm {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stopGeneration");
     method(_javaPart);
   }
+  ModelCapabilities JHybridLiteRTLMSpec::checkModelCapabilities(const std::string& modelPath) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JModelCapabilities>(jni::alias_ref<jni::JString> /* modelPath */)>("checkModelCapabilities");
+    auto __result = method(_javaPart, jni::make_jstring(modelPath));
+    return __result->toCpp();
+  }
   void JHybridLiteRTLMSpec::close() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("close");
     method(_javaPart);

package/nitrogen/generated/android/c++/JHybridLiteRTLMSpec.hpp

@@ -74,6 +74,7 @@ namespace margelo::nitro::litertlm {
     std::shared_ptr<Promise<ExecuteResult>> sendToolResponse(const std::vector<ToolResponse>& responses, const std::optional<std::function<void(const std::string& /* token */, bool /* done */)>>& onToken) override;
     Backend getActiveBackend() override;
     void stopGeneration() override;
+    ModelCapabilities checkModelCapabilities(const std::string& modelPath) override;
     void close() override;
 
   private:

package/nitrogen/generated/android/c++/JLLMConfig.hpp

@@ -23,7 +23,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "LLMConfig" and the the Kotlin data class "LLMConfig".
+   * The C++ JNI bridge between the C++ struct "LLMConfig" and the Kotlin data class "LLMConfig".
    */
   struct JLLMConfig final: public jni::JavaClass<JLLMConfig> {
   public:

package/nitrogen/generated/android/c++/JMemoryUsage.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "MemoryUsage" and the the Kotlin data class "MemoryUsage".
+   * The C++ JNI bridge between the C++ struct "MemoryUsage" and the Kotlin data class "MemoryUsage".
    */
   struct JMemoryUsage final: public jni::JavaClass<JMemoryUsage> {
   public:

package/nitrogen/generated/android/c++/JMessage.hpp

@@ -19,7 +19,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "Message" and the the Kotlin data class "Message".
+   * The C++ JNI bridge between the C++ struct "Message" and the Kotlin data class "Message".
    */
   struct JMessage final: public jni::JavaClass<JMessage> {
   public:

package/nitrogen/generated/android/c++/JModelCapabilities.hpp

@@ -0,0 +1,57 @@
+///
+/// JModelCapabilities.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ModelCapabilities.hpp"
+
+
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ModelCapabilities" and the Kotlin data class "ModelCapabilities".
+   */
+  struct JModelCapabilities final: public jni::JavaClass<JModelCapabilities> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/ModelCapabilities;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ModelCapabilities by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ModelCapabilities toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSupportsSpeculativeDecoding = clazz->getField<jboolean>("supportsSpeculativeDecoding");
+      jboolean supportsSpeculativeDecoding = this->getFieldValue(fieldSupportsSpeculativeDecoding);
+      return ModelCapabilities(
+        static_cast<bool>(supportsSpeculativeDecoding)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JModelCapabilities::javaobject> fromCpp(const ModelCapabilities& value) {
+      using JSignature = JModelCapabilities(jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.supportsSpeculativeDecoding
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/c++/JModelFile.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "ModelFile" and the the Kotlin data class "ModelFile".
+   * The C++ JNI bridge between the C++ struct "ModelFile" and the Kotlin data class "ModelFile".
    */
   struct JModelFile final: public jni::JavaClass<JModelFile> {
   public:

package/nitrogen/generated/android/c++/JMultimodalPart.hpp

@@ -22,7 +22,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "MultimodalPart" and the the Kotlin data class "MultimodalPart".
+   * The C++ JNI bridge between the C++ struct "MultimodalPart" and the Kotlin data class "MultimodalPart".
    */
   struct JMultimodalPart final: public jni::JavaClass<JMultimodalPart> {
   public:

package/nitrogen/generated/android/c++/JPartType.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ enum "PartType" and the the Kotlin enum "PartType".
+   * The C++ JNI bridge between the C++ enum "PartType" and the Kotlin enum "PartType".
    */
   struct JPartType final: public jni::JavaClass<JPartType> {
   public:

package/nitrogen/generated/android/c++/JRole.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ enum "Role" and the the Kotlin enum "Role".
+   * The C++ JNI bridge between the C++ enum "Role" and the Kotlin enum "Role".
    */
   struct JRole final: public jni::JavaClass<JRole> {
   public:

package/nitrogen/generated/android/c++/JToolCall.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "ToolCall" and the the Kotlin data class "ToolCall".
+   * The C++ JNI bridge between the C++ struct "ToolCall" and the Kotlin data class "ToolCall".
    */
   struct JToolCall final: public jni::JavaClass<JToolCall> {
   public:

package/nitrogen/generated/android/c++/JToolDefinition.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "ToolDefinition" and the the Kotlin data class "ToolDefinition".
+   * The C++ JNI bridge between the C++ struct "ToolDefinition" and the Kotlin data class "ToolDefinition".
    */
   struct JToolDefinition final: public jni::JavaClass<JToolDefinition> {
   public:

package/nitrogen/generated/android/c++/JToolResponse.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::litertlm {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "ToolResponse" and the the Kotlin data class "ToolResponse".
+   * The C++ JNI bridge between the C++ struct "ToolResponse" and the Kotlin data class "ToolResponse".
    */
   struct JToolResponse final: public jni::JavaClass<JToolResponse> {
   public:

package/nitrogen/generated/android/kotlin/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMSpec.kt

@@ -139,6 +139,10 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun stopGeneration(): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun checkModelCapabilities(modelPath: String): ModelCapabilities
+  
   @DoNotStrip
   @Keep
   abstract fun close(): Unit

package/nitrogen/generated/android/kotlin/com/margelo/nitro/dev/litert/litertlm/ModelCapabilities.kt

@@ -0,0 +1,51 @@
+///
+/// ModelCapabilities.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.dev.litert.litertlm
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "ModelCapabilities".
+ */
+@DoNotStrip
+@Keep
+data class ModelCapabilities(
+  @DoNotStrip
+  @Keep
+  val supportsSpeculativeDecoding: Boolean
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is ModelCapabilities) return false
+    return Objects.deepEquals(this.supportsSpeculativeDecoding, other.supportsSpeculativeDecoding)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      supportsSpeculativeDecoding
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(supportsSpeculativeDecoding: Boolean): ModelCapabilities {
+      return ModelCapabilities(supportsSpeculativeDecoding)
+    }
+  }
+}

package/nitrogen/generated/ios/LiteRTLM-Swift-Cxx-Bridge.hpp

@@ -26,6 +26,8 @@ namespace margelo::nitro::litertlm { struct LLMConfig; }
 namespace margelo::nitro::litertlm { struct MemoryUsage; }
 // Forward declaration of `Message` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct Message; }
+// Forward declaration of `ModelCapabilities` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct ModelCapabilities; }
 // Forward declaration of `ModelFile` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct ModelFile; }
 // Forward declaration of `MultimodalPart` to properly resolve imports.
@@ -56,6 +58,7 @@ namespace LiteRTLM { class HybridModelStoreSpec_cxx; }
 #include "LLMConfig.hpp"
 #include "MemoryUsage.hpp"
 #include "Message.hpp"
+#include "ModelCapabilities.hpp"
 #include "ModelFile.hpp"
 #include "MultimodalPart.hpp"
 #include "PartType.hpp"
@@ -541,6 +544,15 @@ namespace margelo::nitro::litertlm::bridge::swift {
     return Result<Backend>::withError(error);
   }
   
+  // pragma MARK: Result<ModelCapabilities>
+  using Result_ModelCapabilities_ = Result<ModelCapabilities>;
+  inline Result_ModelCapabilities_ create_Result_ModelCapabilities_(const ModelCapabilities& value) noexcept {
+    return Result<ModelCapabilities>::withValue(value);
+  }
+  inline Result_ModelCapabilities_ create_Result_ModelCapabilities_(const std::exception_ptr& error) noexcept {
+    return Result<ModelCapabilities>::withError(error);
+  }
+  
   // pragma MARK: std::vector<ModelFile>
   /**
    * Specialized version of `std::vector<ModelFile>`.

package/nitrogen/generated/ios/LiteRTLM-Swift-Cxx-Umbrella.hpp

@@ -24,6 +24,8 @@ namespace margelo::nitro::litertlm { struct LLMConfig; }
 namespace margelo::nitro::litertlm { struct MemoryUsage; }
 // Forward declaration of `Message` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct Message; }
+// Forward declaration of `ModelCapabilities` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct ModelCapabilities; }
 // Forward declaration of `ModelFile` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct ModelFile; }
 // Forward declaration of `MultimodalPart` to properly resolve imports.
@@ -48,6 +50,7 @@ namespace margelo::nitro::litertlm { struct ToolResponse; }
 #include "LLMConfig.hpp"
 #include "MemoryUsage.hpp"
 #include "Message.hpp"
+#include "ModelCapabilities.hpp"
 #include "ModelFile.hpp"
 #include "MultimodalPart.hpp"
 #include "PartType.hpp"

package/nitrogen/generated/ios/c++/HybridLiteRTLMSpecSwift.hpp

@@ -38,6 +38,8 @@ namespace margelo::nitro::litertlm { struct GenerationStats; }
 namespace margelo::nitro::litertlm { struct MemoryUsage; }
 // Forward declaration of `ToolResponse` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct ToolResponse; }
+// Forward declaration of `ModelCapabilities` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct ModelCapabilities; }
 
 #include <NitroModules/Promise.hpp>
 #include <string>
@@ -58,6 +60,7 @@ namespace margelo::nitro::litertlm { struct ToolResponse; }
 #include "GenerationStats.hpp"
 #include "MemoryUsage.hpp"
 #include "ToolResponse.hpp"
+#include "ModelCapabilities.hpp"
 
 #include "LiteRTLM-Swift-Cxx-Umbrella.hpp"
 
@@ -265,6 +268,14 @@ namespace margelo::nitro::litertlm {
         std::rethrow_exception(__result.error());
       }
     }
+    inline ModelCapabilities checkModelCapabilities(const std::string& modelPath) override {
+      auto __result = _swiftPart.checkModelCapabilities(modelPath);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void close() override {
       auto __result = _swiftPart.close();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridLiteRTLMSpec.swift

@@ -33,6 +33,7 @@ public protocol HybridLiteRTLMSpec_protocol: HybridObject {
   func sendToolResponse(responses: [ToolResponse], onToken: ((_ token: String, _ done: Bool) -> Void)?) throws -> Promise<ExecuteResult>
   func getActiveBackend() throws -> Backend
   func stopGeneration() throws -> Void
+  func checkModelCapabilities(modelPath: String) throws -> ModelCapabilities
   func close() throws -> Void
 }
 

package/nitrogen/generated/ios/swift/HybridLiteRTLMSpec_cxx.swift

@@ -503,6 +503,18 @@ open class HybridLiteRTLMSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func checkModelCapabilities(modelPath: std.string) -> bridge.Result_ModelCapabilities_ {
+    do {
+      let __result = try self.__implementation.checkModelCapabilities(modelPath: String(modelPath))
+      let __resultCpp = __result
+      return bridge.create_Result_ModelCapabilities_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_ModelCapabilities_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func close() -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/ModelCapabilities.swift

@@ -0,0 +1,29 @@
+///
+/// ModelCapabilities.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ModelCapabilities`, backed by a C++ struct.
+ */
+public typealias ModelCapabilities = margelo.nitro.litertlm.ModelCapabilities
+
+public extension ModelCapabilities {
+  private typealias bridge = margelo.nitro.litertlm.bridge.swift
+
+  /**
+   * Create a new instance of `ModelCapabilities`.
+   */
+  init(supportsSpeculativeDecoding: Bool) {
+    self.init(supportsSpeculativeDecoding)
+  }
+
+  @inline(__always)
+  var supportsSpeculativeDecoding: Bool {
+    return self.__supportsSpeculativeDecoding
+  }
+}

package/nitrogen/generated/shared/c++/HybridLiteRTLMSpec.cpp

@@ -34,6 +34,7 @@ namespace margelo::nitro::litertlm {
       prototype.registerHybridMethod("sendToolResponse", &HybridLiteRTLMSpec::sendToolResponse);
       prototype.registerHybridMethod("getActiveBackend", &HybridLiteRTLMSpec::getActiveBackend);
       prototype.registerHybridMethod("stopGeneration", &HybridLiteRTLMSpec::stopGeneration);
+      prototype.registerHybridMethod("checkModelCapabilities", &HybridLiteRTLMSpec::checkModelCapabilities);
       prototype.registerHybridMethod("close", &HybridLiteRTLMSpec::close);
     });
   }

package/nitrogen/generated/shared/c++/HybridLiteRTLMSpec.hpp

@@ -29,6 +29,8 @@ namespace margelo::nitro::litertlm { struct MemoryUsage; }
 namespace margelo::nitro::litertlm { struct ToolResponse; }
 // Forward declaration of `Backend` to properly resolve imports.
 namespace margelo::nitro::litertlm { enum class Backend; }
+// Forward declaration of `ModelCapabilities` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct ModelCapabilities; }
 
 #include <NitroModules/Promise.hpp>
 #include <string>
@@ -43,6 +45,7 @@ namespace margelo::nitro::litertlm { enum class Backend; }
 #include "MemoryUsage.hpp"
 #include "ToolResponse.hpp"
 #include "Backend.hpp"
+#include "ModelCapabilities.hpp"
 
 namespace margelo::nitro::litertlm {
 
@@ -95,6 +98,7 @@ namespace margelo::nitro::litertlm {
       virtual std::shared_ptr<Promise<ExecuteResult>> sendToolResponse(const std::vector<ToolResponse>& responses, const std::optional<std::function<void(const std::string& /* token */, bool /* done */)>>& onToken) = 0;
       virtual Backend getActiveBackend() = 0;
       virtual void stopGeneration() = 0;
+      virtual ModelCapabilities checkModelCapabilities(const std::string& modelPath) = 0;
       virtual void close() = 0;
 
     protected:

package/nitrogen/generated/shared/c++/ModelCapabilities.hpp

@@ -0,0 +1,83 @@
+///
+/// ModelCapabilities.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::litertlm {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ModelCapabilities).
+   */
+  struct ModelCapabilities final {
+  public:
+    bool supportsSpeculativeDecoding     SWIFT_PRIVATE;
+
+  public:
+    ModelCapabilities() = default;
+    explicit ModelCapabilities(bool supportsSpeculativeDecoding): supportsSpeculativeDecoding(supportsSpeculativeDecoding) {}
+
+  public:
+    friend bool operator==(const ModelCapabilities& lhs, const ModelCapabilities& rhs) = default;
+  };
+
+} // namespace margelo::nitro::litertlm
+
+namespace margelo::nitro {
+
+  // C++ ModelCapabilities <> JS ModelCapabilities (object)
+  template <>
+  struct JSIConverter<margelo::nitro::litertlm::ModelCapabilities> final {
+    static inline margelo::nitro::litertlm::ModelCapabilities fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::litertlm::ModelCapabilities(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "supportsSpeculativeDecoding")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::litertlm::ModelCapabilities& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "supportsSpeculativeDecoding"), JSIConverter<bool>::toJSI(runtime, arg.supportsSpeculativeDecoding));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "supportsSpeculativeDecoding")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dr33m/react-native-litert-lm",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "litertLm": {
     "version": "0.12.0",
     "androidMavenVersion": "0.12.0",

package/src/index.ts

@@ -18,6 +18,7 @@ export type {
   Role,
   GenerationStats,
   MemoryUsage,
+  ModelCapabilities,
   /** New in v0.5: pass to execute() instead of individual send methods */
   MultimodalPart,
   PartType,

package/src/specs/LiteRTLM.nitro.ts

@@ -232,6 +232,15 @@ export interface MemoryUsage {
   isLowMemory: boolean;
 }
 
+/**
+ * Model capability flags queried from the model file at runtime.
+ * Uses the LiteRT-LM Capabilities API to inspect compiled model metadata.
+ */
+export interface ModelCapabilities {
+  /** Whether the model binary supports multi-token prediction (speculative decoding). */
+  supportsSpeculativeDecoding: boolean;
+}
+
 /**
  * LiteRT-LM: High-performance LLM inference engine.
  * Supports Gemma 4, Gemma 3n, Phi-4, Qwen, and other .litertlm models.
@@ -420,6 +429,14 @@ export interface LiteRTLM extends HybridObject<{
    */
   stopGeneration(): void;
 
+  /**
+   * Query model capabilities from the compiled model file.
+   * Does NOT require loadModel() — reads metadata directly from disk.
+   * @param modelPath Absolute path to the .litertlm model file.
+   * @returns Capabilities flags (e.g. speculative decoding support).
+   */
+  checkModelCapabilities(modelPath: string): ModelCapabilities;
+
   /**
    * Release all native resources.
    * Call this when done with the LLM instance.