react-native-litert-lm 0.2.0 → 0.2.2

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

@@ -17,6 +17,9 @@ import com.facebook.proguard.annotations.DoNotStrip
 @DoNotStrip
 @Keep
 data class LLMConfig(
+  @DoNotStrip
+  @Keep
+  val systemPrompt: String?,
   @DoNotStrip
   @Keep
   val backend: Backend?,
@@ -43,8 +46,8 @@ data class LLMConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(backend: Backend?, maxTokens: Double?, temperature: Double?, topK: Double?, topP: Double?): LLMConfig {
-      return LLMConfig(backend, maxTokens, temperature, topK, topP)
+    private fun fromCpp(systemPrompt: String?, backend: Backend?, maxTokens: Double?, temperature: Double?, topK: Double?, topP: Double?): LLMConfig {
+      return LLMConfig(systemPrompt, backend, maxTokens, temperature, topK, topP)
     }
   }
 }

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

@@ -0,0 +1,47 @@
+///
+/// MemoryUsage.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
+
+
+/**
+ * Represents the JavaScript object/struct "MemoryUsage".
+ */
+@DoNotStrip
+@Keep
+data class MemoryUsage(
+  @DoNotStrip
+  @Keep
+  val nativeHeapBytes: Double,
+  @DoNotStrip
+  @Keep
+  val residentBytes: Double,
+  @DoNotStrip
+  @Keep
+  val availableMemoryBytes: Double,
+  @DoNotStrip
+  @Keep
+  val isLowMemory: Boolean
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(nativeHeapBytes: Double, residentBytes: Double, availableMemoryBytes: Double, isLowMemory: Boolean): MemoryUsage {
+      return MemoryUsage(nativeHeapBytes, residentBytes, availableMemoryBytes, isLowMemory)
+    }
+  }
+}

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

@@ -17,12 +17,15 @@ namespace margelo::nitro::litertlm {
       prototype.registerHybridMethod("loadModel", &HybridLiteRTLMSpec::loadModel);
       prototype.registerHybridMethod("sendMessage", &HybridLiteRTLMSpec::sendMessage);
       prototype.registerHybridMethod("sendMessageWithImage", &HybridLiteRTLMSpec::sendMessageWithImage);
+      prototype.registerHybridMethod("downloadModel", &HybridLiteRTLMSpec::downloadModel);
+      prototype.registerHybridMethod("deleteModel", &HybridLiteRTLMSpec::deleteModel);
       prototype.registerHybridMethod("sendMessageWithAudio", &HybridLiteRTLMSpec::sendMessageWithAudio);
       prototype.registerHybridMethod("sendMessageAsync", &HybridLiteRTLMSpec::sendMessageAsync);
       prototype.registerHybridMethod("getHistory", &HybridLiteRTLMSpec::getHistory);
       prototype.registerHybridMethod("resetConversation", &HybridLiteRTLMSpec::resetConversation);
       prototype.registerHybridMethod("isReady", &HybridLiteRTLMSpec::isReady);
       prototype.registerHybridMethod("getStats", &HybridLiteRTLMSpec::getStats);
+      prototype.registerHybridMethod("getMemoryUsage", &HybridLiteRTLMSpec::getMemoryUsage);
       prototype.registerHybridMethod("close", &HybridLiteRTLMSpec::close);
     });
   }

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

@@ -19,6 +19,8 @@ namespace margelo::nitro::litertlm { struct LLMConfig; }
 namespace margelo::nitro::litertlm { struct Message; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct GenerationStats; }
+// Forward declaration of `MemoryUsage` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct MemoryUsage; }
 
 #include <NitroModules/Promise.hpp>
 #include <string>
@@ -28,6 +30,7 @@ namespace margelo::nitro::litertlm { struct GenerationStats; }
 #include "Message.hpp"
 #include <vector>
 #include "GenerationStats.hpp"
+#include "MemoryUsage.hpp"
 
 namespace margelo::nitro::litertlm {
 
@@ -63,12 +66,15 @@ namespace margelo::nitro::litertlm {
       virtual std::shared_ptr<Promise<void>> loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) = 0;
       virtual std::shared_ptr<Promise<std::string>> sendMessage(const std::string& message) = 0;
       virtual std::shared_ptr<Promise<std::string>> sendMessageWithImage(const std::string& message, const std::string& imagePath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> downloadModel(const std::string& url, const std::string& fileName, const std::optional<std::function<void(double /* progress */)>>& onProgress) = 0;
+      virtual std::shared_ptr<Promise<void>> deleteModel(const std::string& fileName) = 0;
       virtual std::shared_ptr<Promise<std::string>> sendMessageWithAudio(const std::string& message, const std::string& audioPath) = 0;
       virtual void sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) = 0;
       virtual std::vector<Message> getHistory() = 0;
       virtual void resetConversation() = 0;
       virtual bool isReady() = 0;
       virtual GenerationStats getStats() = 0;
+      virtual MemoryUsage getMemoryUsage() = 0;
       virtual void close() = 0;
 
     protected:

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

@@ -31,8 +31,9 @@
 // Forward declaration of `Backend` to properly resolve imports.
 namespace margelo::nitro::litertlm { enum class Backend; }
 
-#include "Backend.hpp"
+#include <string>
 #include <optional>
+#include "Backend.hpp"
 
 namespace margelo::nitro::litertlm {
 
@@ -41,6 +42,7 @@ namespace margelo::nitro::litertlm {
    */
   struct LLMConfig final {
   public:
+    std::optional<std::string> systemPrompt     SWIFT_PRIVATE;
     std::optional<Backend> backend     SWIFT_PRIVATE;
     std::optional<double> maxTokens     SWIFT_PRIVATE;
     std::optional<double> temperature     SWIFT_PRIVATE;
@@ -49,7 +51,7 @@ namespace margelo::nitro::litertlm {
 
   public:
     LLMConfig() = default;
-    explicit LLMConfig(std::optional<Backend> backend, std::optional<double> maxTokens, std::optional<double> temperature, std::optional<double> topK, std::optional<double> topP): backend(backend), maxTokens(maxTokens), temperature(temperature), topK(topK), topP(topP) {}
+    explicit LLMConfig(std::optional<std::string> systemPrompt, std::optional<Backend> backend, std::optional<double> maxTokens, std::optional<double> temperature, std::optional<double> topK, std::optional<double> topP): systemPrompt(systemPrompt), backend(backend), maxTokens(maxTokens), temperature(temperature), topK(topK), topP(topP) {}
 
   public:
     friend bool operator==(const LLMConfig& lhs, const LLMConfig& rhs) = default;
@@ -65,6 +67,7 @@ namespace margelo::nitro {
     static inline margelo::nitro::litertlm::LLMConfig fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::litertlm::LLMConfig(
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "systemPrompt"))),
         JSIConverter<std::optional<margelo::nitro::litertlm::Backend>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "backend"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "maxTokens"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "temperature"))),
@@ -74,6 +77,7 @@ namespace margelo::nitro {
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::litertlm::LLMConfig& arg) {
       jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "systemPrompt"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.systemPrompt));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "backend"), JSIConverter<std::optional<margelo::nitro::litertlm::Backend>>::toJSI(runtime, arg.backend));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "maxTokens"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.maxTokens));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "temperature"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.temperature));
@@ -89,6 +93,7 @@ namespace margelo::nitro {
       if (!nitro::isPlainObject(runtime, obj)) {
         return false;
       }
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "systemPrompt")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::litertlm::Backend>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "backend")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "maxTokens")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "temperature")))) return false;

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

@@ -0,0 +1,95 @@
+///
+/// MemoryUsage.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 (MemoryUsage).
+   */
+  struct MemoryUsage final {
+  public:
+    double nativeHeapBytes     SWIFT_PRIVATE;
+    double residentBytes     SWIFT_PRIVATE;
+    double availableMemoryBytes     SWIFT_PRIVATE;
+    bool isLowMemory     SWIFT_PRIVATE;
+
+  public:
+    MemoryUsage() = default;
+    explicit MemoryUsage(double nativeHeapBytes, double residentBytes, double availableMemoryBytes, bool isLowMemory): nativeHeapBytes(nativeHeapBytes), residentBytes(residentBytes), availableMemoryBytes(availableMemoryBytes), isLowMemory(isLowMemory) {}
+
+  public:
+    friend bool operator==(const MemoryUsage& lhs, const MemoryUsage& rhs) = default;
+  };
+
+} // namespace margelo::nitro::litertlm
+
+namespace margelo::nitro {
+
+  // C++ MemoryUsage <> JS MemoryUsage (object)
+  template <>
+  struct JSIConverter<margelo::nitro::litertlm::MemoryUsage> final {
+    static inline margelo::nitro::litertlm::MemoryUsage fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::litertlm::MemoryUsage(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nativeHeapBytes"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "residentBytes"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "availableMemoryBytes"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isLowMemory")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::litertlm::MemoryUsage& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "nativeHeapBytes"), JSIConverter<double>::toJSI(runtime, arg.nativeHeapBytes));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "residentBytes"), JSIConverter<double>::toJSI(runtime, arg.residentBytes));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "availableMemoryBytes"), JSIConverter<double>::toJSI(runtime, arg.availableMemoryBytes));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isLowMemory"), JSIConverter<bool>::toJSI(runtime, arg.isLowMemory));
+      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<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nativeHeapBytes")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "residentBytes")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "availableMemoryBytes")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isLowMemory")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-litert-lm",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "High-performance LLM inference for React Native using LiteRT-LM. Optimized for Gemma 3n and other on-device language models.",
   "license": "MIT",
   "author": "Hugh Chen (https://github.com/hung-yueh)",
@@ -65,7 +65,7 @@
     "@expo/config-plugins": "~54.0.4",
     "@types/react": "~19.1.10",
     "expo": "^54.0.31",
-    "nitrogen": "^0.33.2",
+    "nitrogen": "^0.34.1",
     "react": "19.1.0",
     "react-native": "0.81.5",
     "release-it": "^19.2.4",
@@ -82,6 +82,6 @@
     }
   },
   "dependencies": {
-    "react-native-nitro-modules": "^0.33.2"
+    "react-native-nitro-modules": "^0.34.1"
   }
 }

package/src/hooks.ts

@@ -0,0 +1,195 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+import { LiteRTLM, LLMConfig } from "./index";
+import { createLLM } from "./modelFactory";
+import type { MemoryTracker, MemoryTrackerSummary } from "./memoryTracker";
+
+export interface UseModelConfig extends LLMConfig {
+  autoLoad?: boolean;
+  /**
+   * Enable memory tracking using native ArrayBuffers (v0.34+).
+   * When enabled, memory usage is tracked after each inference call
+   * using `NitroModules.createNativeArrayBuffer()` for zero-copy storage.
+   * @default false
+   */
+  enableMemoryTracking?: boolean;
+  /**
+   * Maximum number of memory snapshots to store.
+   * Each snapshot uses 32 bytes of native memory.
+   * @default 256
+   */
+  maxMemorySnapshots?: number;
+}
+
+export interface UseModelResult {
+  model: LiteRTLM | null;
+  isReady: boolean;
+  isGenerating: boolean;
+  downloadProgress: number;
+  error: string | null;
+  generate: (prompt: string) => Promise<string>;
+  reset: () => void;
+  deleteModel: (fileName: string) => Promise<void>;
+  load: () => Promise<void>;
+  /**
+   * Memory tracker instance (available when enableMemoryTracking is true).
+   * Uses native ArrayBuffers allocated via `NitroModules.createNativeArrayBuffer()`
+   * for efficient, zero-copy memory usage tracking.
+   */
+  memoryTracker: MemoryTracker | null;
+  /**
+   * Current memory tracking summary (null if tracking is disabled).
+   * Updates automatically after each inference call.
+   */
+  memorySummary: MemoryTrackerSummary | null;
+}
+
+export function useModel(
+  pathOrUrl: string,
+  config?: UseModelConfig,
+): UseModelResult {
+  const modelRef = useRef<(LiteRTLM & { memoryTracker?: MemoryTracker }) | null>(null);
+  const [isReady, setIsReady] = useState(false);
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [downloadProgress, setDownloadProgress] = useState(0);
+  const [error, setError] = useState<string | null>(null);
+  const [memorySummary, setMemorySummary] = useState<MemoryTrackerSummary | null>(null);
+
+  // Extract autoLoad (default true) and memory tracking options
+  const autoLoad = config?.autoLoad ?? true;
+  const enableMemoryTracking = config?.enableMemoryTracking ?? false;
+  const maxMemorySnapshots = config?.maxMemorySnapshots ?? 256;
+
+  /**
+   * Refresh memory summary from the tracker's native buffer.
+   */
+  const refreshMemorySummary = useCallback(() => {
+    if (modelRef.current?.memoryTracker) {
+      setMemorySummary(modelRef.current.memoryTracker.getSummary());
+    }
+  }, []);
+
+  // Initialize the model instance
+  useEffect(() => {
+    modelRef.current = createLLM({
+      enableMemoryTracking,
+      maxMemorySnapshots,
+    });
+    let isMounted = true;
+
+    // Cleanup on unmount
+    return () => {
+      isMounted = false;
+      try {
+        modelRef.current?.close();
+      } catch (e) {
+        console.warn("Failed to close model", e);
+      }
+    };
+  }, [enableMemoryTracking, maxMemorySnapshots]);
+
+  const load = useCallback(async () => {
+    setIsReady(false);
+    setError(null);
+    setDownloadProgress(0);
+
+    try {
+      let modelPath = pathOrUrl;
+
+      // Handle URL download manually to capture progress
+      if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+        const fileName = pathOrUrl.split("/").pop() || "model.bin";
+
+        if (modelRef.current) {
+          modelPath = await modelRef.current.downloadModel(
+            pathOrUrl,
+            fileName,
+            (progress) => {
+              setDownloadProgress(progress);
+            },
+          );
+        }
+      }
+
+      if (modelRef.current) {
+        // Create a clean config object for native loadModel (excluding autoLoad)
+        const nativeConfig: LLMConfig = { ...config };
+        delete (nativeConfig as any).autoLoad;
+
+        await modelRef.current.loadModel(modelPath, nativeConfig);
+        setIsReady(true);
+      }
+    } catch (e: any) {
+      setError(e.message || "Failed to load model");
+      console.error(e);
+    }
+  }, [pathOrUrl, config]);
+
+  useEffect(() => {
+    if (autoLoad) {
+      load();
+    }
+  }, [autoLoad, load]);
+
+  const generate = useCallback(
+    async (prompt: string): Promise<string> => {
+      if (!modelRef.current || !isReady) {
+        throw new Error("Model not ready");
+      }
+
+      setIsGenerating(true);
+      try {
+        return new Promise<string>((resolve, reject) => {
+          let fullResponse = "";
+          try {
+            modelRef.current?.sendMessageAsync(
+              prompt,
+              (token: string, done: boolean) => {
+                fullResponse += token;
+                if (done) {
+                  refreshMemorySummary();
+                  resolve(fullResponse);
+                }
+              },
+            );
+          } catch (e: any) {
+            reject(e);
+          }
+        });
+      } catch (e: any) {
+        setError(e.message || "Generation failed");
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [isReady, refreshMemorySummary],
+  );
+
+  const reset = useCallback(() => {
+    if (modelRef.current) {
+      modelRef.current.resetConversation();
+    }
+  }, []);
+
+  const deleteModel = useCallback(async (fileName: string): Promise<void> => {
+    if (modelRef.current) {
+      await modelRef.current.deleteModel(fileName);
+      setIsReady(false);
+      setDownloadProgress(0);
+    }
+  }, []);
+
+  return {
+    model: modelRef.current,
+    isReady,
+    isGenerating,
+    downloadProgress,
+    error,
+    generate,
+    reset,
+    deleteModel,
+    load,
+    memoryTracker: modelRef.current?.memoryTracker ?? null,
+    memorySummary,
+  };
+}

package/src/index.ts

@@ -7,6 +7,7 @@ import type {
   Backend,
   Role,
   GenerationStats,
+  MemoryUsage,
 } from "./specs/LiteRTLM.nitro";
 
 export type {
@@ -16,8 +17,27 @@ export type {
   Backend,
   Role,
   GenerationStats,
+  MemoryUsage,
 } from "./specs/LiteRTLM.nitro";
 
+// Re-export template utilities
+export type { ChatMessage } from "./templates";
+export {
+  applyGemmaTemplate,
+  applyPhiTemplate,
+  applyLlamaTemplate,
+} from "./templates";
+
+// Re-export memory tracking utilities (uses NitroModules.createNativeArrayBuffer v0.34+)
+export type {
+  MemorySnapshot,
+  MemoryTracker,
+  MemoryTrackerSummary,
+} from "./memoryTracker";
+export { createMemoryTracker, createNativeBuffer } from "./memoryTracker";
+
+export * from "./hooks";
+
 /**
  * Creates a new LiteRT-LM inference engine instance.
  *
@@ -51,9 +71,7 @@ export type {
  * llm.close();
  * ```
  */
-export function createLLM(): LiteRTLM {
-  return NitroModules.createHybridObject<LiteRTLM>("LiteRTLM");
-}
+export { createLLM } from "./modelFactory";
 
 /**
  * Pre-defined model identifiers for common models.
@@ -123,3 +141,33 @@ export function checkBackendSupport(backend: Backend): string | undefined {
 
   return undefined;
 }
+
+/**
+ * Check if multimodal features (image/audio) are supported on the current platform.
+ * Returns an error message if not supported, undefined if OK.
+ *
+ * @returns Error message if multimodal is not supported, undefined if OK
+ *
+ * @example
+ * ```typescript
+ * const error = checkMultimodalSupport();
+ * if (error) {
+ *   console.warn(error);
+ *   // Fall back to text-only
+ * } else {
+ *   llm.sendMessageWithImage('Describe this', imagePath);
+ * }
+ * ```
+ */
+export function checkMultimodalSupport(): string | undefined {
+  if (Platform.OS === "ios") {
+    return "Multimodal (image/audio) is not yet supported on iOS. LiteRT-LM iOS SDK is pending.";
+  }
+  return undefined;
+}
+
+/**
+ * Download URL for the Gemma 3n E2B IT INT4 model.
+ */
+export const GEMMA_3N_E2B_IT_INT4 =
+  "https://litert.dev/gemma-3n-E2B-it-int4.litertlm";