react-native-litert-lm 0.2.2 → 0.3.1

package/ios/IOSDownloadHelper.mm

@@ -0,0 +1,129 @@
+#import <Foundation/Foundation.h>
+#include "../cpp/IOSDownloadHelper.h"
+#include <stdexcept>
+
+namespace litert_lm {
+
+std::string downloadModelFile(
+    const std::string& url,
+    const std::string& fileName,
+    const std::optional<std::function<void(double)>>& onProgress) {
+  @autoreleasepool {
+    NSString* nsUrl = [NSString stringWithUTF8String:url.c_str()];
+    NSString* nsFileName = [NSString stringWithUTF8String:fileName.c_str()];
+    
+    // Use Caches directory — survives app relaunch but can be
+    // reclaimed by the system under storage pressure.
+    NSString* cachesDir = NSSearchPathForDirectoriesInDomains(
+        NSCachesDirectory, NSUserDomainMask, YES).firstObject;
+    NSString* modelsDir = [cachesDir stringByAppendingPathComponent:@"litert_models"];
+    
+    // Create models subdirectory
+    NSFileManager* fm = [NSFileManager defaultManager];
+    if (![fm fileExistsAtPath:modelsDir]) {
+      [fm createDirectoryAtPath:modelsDir
+          withIntermediateDirectories:YES
+                          attributes:nil
+                               error:nil];
+    }
+    
+    NSString* destPath = [modelsDir stringByAppendingPathComponent:nsFileName];
+    
+    // If the file already exists and has content, skip download
+    if ([fm fileExistsAtPath:destPath]) {
+      NSDictionary* attrs = [fm attributesOfItemAtPath:destPath error:nil];
+      unsigned long long fileSize = [attrs fileSize];
+      if (fileSize > 0) {
+        NSLog(@"[LiteRTLM] Model already cached at %@ (%llu bytes), skipping download",
+              destPath, fileSize);
+        if (onProgress.has_value()) {
+          onProgress.value()(1.0);
+        }
+        return std::string([destPath UTF8String]);
+      }
+    }
+    
+    NSLog(@"[LiteRTLM] Downloading model from %@ to %@", nsUrl, destPath);
+    
+    NSURL* requestUrl = [NSURL URLWithString:nsUrl];
+    if (!requestUrl) {
+      throw std::runtime_error("Invalid download URL: " + url);
+    }
+    
+    // Synchronous download using NSURLSession on this background thread.
+    __block NSError* downloadError = nil;
+    
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    
+    NSURLSessionConfiguration* config = [NSURLSessionConfiguration defaultSessionConfiguration];
+    config.timeoutIntervalForRequest = 30;
+    config.timeoutIntervalForResource = 3600; // 1 hour for large models
+    
+    NSURLSession* session = [NSURLSession sessionWithConfiguration:config];
+    NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:requestUrl];
+    [request setHTTPMethod:@"GET"];
+    
+    // Use downloadTask for proper progress tracking and disk-efficient downloads
+    NSURLSessionDownloadTask* task = [session downloadTaskWithRequest:request
+        completionHandler:^(NSURL* location, NSURLResponse* response, NSError* error) {
+      if (error) {
+        downloadError = error;
+        dispatch_semaphore_signal(semaphore);
+        return;
+      }
+      
+      // Check HTTP status
+      if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
+        NSInteger statusCode = [(NSHTTPURLResponse*)response statusCode];
+        if (statusCode >= 400) {
+          downloadError = [NSError errorWithDomain:@"LiteRTLM"
+                                              code:statusCode
+                                          userInfo:@{NSLocalizedDescriptionKey:
+              [NSString stringWithFormat:@"HTTP %ld", (long)statusCode]}];
+          dispatch_semaphore_signal(semaphore);
+          return;
+        }
+      }
+      
+      // Move downloaded file to destination
+      NSError* moveError = nil;
+      [fm removeItemAtPath:destPath error:nil]; // Remove any partial file
+      if (![fm moveItemAtURL:location
+                       toURL:[NSURL fileURLWithPath:destPath]
+                       error:&moveError]) {
+        downloadError = moveError;
+      }
+      
+      dispatch_semaphore_signal(semaphore);
+    }];
+    
+    [task resume];
+    
+    // Poll for progress while waiting for completion
+    while (dispatch_semaphore_wait(semaphore,
+           dispatch_time(DISPATCH_TIME_NOW, 500 * NSEC_PER_MSEC)) != 0) {
+      if (onProgress.has_value() && task.countOfBytesExpectedToReceive > 0) {
+        double progress = (double)task.countOfBytesReceived /
+                          (double)task.countOfBytesExpectedToReceive;
+        onProgress.value()(progress);
+      }
+    }
+    
+    [session finishTasksAndInvalidate];
+    
+    if (downloadError) {
+      throw std::runtime_error("Download failed: " + 
+          std::string([[downloadError localizedDescription] UTF8String]));
+    }
+    
+    // Final progress callback
+    if (onProgress.has_value()) {
+      onProgress.value()(1.0);
+    }
+    
+    NSLog(@"[LiteRTLM] Model downloaded successfully to %@", destPath);
+    return std::string([destPath UTF8String]);
+  }
+}
+
+} // namespace litert_lm

package/ios/LiteRTLMAutolinking.mm

@@ -0,0 +1,30 @@
+///
+/// LiteRTLMAutolinking.mm
+/// Registers the C++ HybridLiteRTLM implementation with NitroModules on iOS.
+///
+/// On iOS, there's no JNI_OnLoad equivalent, so we use ObjC +load to register
+/// the HybridObject factory before JS tries to create it.
+///
+
+#import <Foundation/Foundation.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+#include "HybridLiteRTLM.hpp"
+
+@interface LiteRTLMAutolinking : NSObject
+@end
+
+@implementation LiteRTLMAutolinking
+
++ (void)load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::litertlm;
+  
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "LiteRTLM",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridLiteRTLM>();
+    }
+  );
+}
+
+@end

package/lib/hooks.d.ts

@@ -1,9 +1,10 @@
-import { LiteRTLM, LLMConfig } from "./index";
+import { LLMConfig } from "./index";
+import type { LiteRTLMInstance } from "./modelFactory";
 import type { MemoryTracker, MemoryTrackerSummary } from "./memoryTracker";
 export interface UseModelConfig extends LLMConfig {
     autoLoad?: boolean;
     /**
-     * Enable memory tracking using native ArrayBuffers (v0.34+).
+     * Enable memory tracking using native ArrayBuffers (v0.35+).
      * When enabled, memory usage is tracked after each inference call
      * using `NitroModules.createNativeArrayBuffer()` for zero-copy storage.
      * @default false
@@ -17,14 +18,18 @@ export interface UseModelConfig extends LLMConfig {
     maxMemorySnapshots?: number;
 }
 export interface UseModelResult {
-    model: LiteRTLM | null;
+    model: LiteRTLMInstance | null;
     isReady: boolean;
     isGenerating: boolean;
     downloadProgress: number;
     error: string | null;
     generate: (prompt: string) => Promise<string>;
     reset: () => void;
-    deleteModel: (fileName: string) => Promise<void>;
+    /**
+     * Delete the model file. If no fileName is provided, derives it from
+     * the URL/path passed to useModel.
+     */
+    deleteModel: (fileName?: string) => Promise<void>;
     load: () => Promise<void>;
     /**
      * Memory tracker instance (available when enableMemoryTracking is true).

package/lib/hooks.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useModel = useModel;
 const react_1 = require("react");
 const modelFactory_1 = require("./modelFactory");
+/**
+ * Extract a filename from a URL or file path.
+ */
+function extractFileName(pathOrUrl) {
+    return pathOrUrl.split("/").pop() || "model.bin";
+}
 function useModel(pathOrUrl, config) {
     const modelRef = (0, react_1.useRef)(null);
     const [isReady, setIsReady] = (0, react_1.useState)(false);
@@ -10,10 +16,27 @@ function useModel(pathOrUrl, config) {
     const [downloadProgress, setDownloadProgress] = (0, react_1.useState)(0);
     const [error, setError] = (0, react_1.useState)(null);
     const [memorySummary, setMemorySummary] = (0, react_1.useState)(null);
-    // Extract autoLoad (default true) and memory tracking options
+    // Destructure config into primitive values for stable dependency arrays.
+    // This prevents infinite re-render loops when consumers pass inline config
+    // objects (e.g. useModel(url, { backend: 'cpu' })) without useMemo.
     const autoLoad = config?.autoLoad ?? true;
     const enableMemoryTracking = config?.enableMemoryTracking ?? false;
     const maxMemorySnapshots = config?.maxMemorySnapshots ?? 256;
+    const backend = config?.backend;
+    const systemPrompt = config?.systemPrompt;
+    const maxTokens = config?.maxTokens;
+    const temperature = config?.temperature;
+    const topK = config?.topK;
+    const topP = config?.topP;
+    // Build a stable config object from the destructured primitives
+    const nativeConfig = (0, react_1.useMemo)(() => ({
+        ...(backend !== undefined && { backend }),
+        ...(systemPrompt !== undefined && { systemPrompt }),
+        ...(maxTokens !== undefined && { maxTokens }),
+        ...(temperature !== undefined && { temperature }),
+        ...(topK !== undefined && { topK }),
+        ...(topP !== undefined && { topP }),
+    }), [backend, systemPrompt, maxTokens, temperature, topK, topP]);
     /**
      * Refresh memory summary from the tracker's native buffer.
      */
@@ -28,10 +51,8 @@ function useModel(pathOrUrl, config) {
             enableMemoryTracking,
             maxMemorySnapshots,
         });
-        let isMounted = true;
         // Cleanup on unmount
         return () => {
-            isMounted = false;
             try {
                 modelRef.current?.close();
             }
@@ -45,21 +66,13 @@ function useModel(pathOrUrl, config) {
         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 = { ...config };
-                delete nativeConfig.autoLoad;
-                await modelRef.current.loadModel(modelPath, nativeConfig);
+                // Delegate URL handling + download to the factory's loadModel,
+                // passing our progress setter as the callback (eliminates
+                // duplicate download logic that was previously in this hook).
+                await modelRef.current.loadModel(pathOrUrl, nativeConfig, (progress) => {
+                    setDownloadProgress(progress);
+                });
                 setIsReady(true);
             }
         }
@@ -67,7 +80,7 @@ function useModel(pathOrUrl, config) {
             setError(e.message || "Failed to load model");
             console.error(e);
         }
-    }, [pathOrUrl, config]);
+    }, [pathOrUrl, nativeConfig]);
     (0, react_1.useEffect)(() => {
         if (autoLoad) {
             load();
@@ -110,11 +123,12 @@ function useModel(pathOrUrl, config) {
     }, []);
     const deleteModel = (0, react_1.useCallback)(async (fileName) => {
         if (modelRef.current) {
-            await modelRef.current.deleteModel(fileName);
+            const resolvedName = fileName ?? extractFileName(pathOrUrl);
+            await modelRef.current.deleteModel(resolvedName);
             setIsReady(false);
             setDownloadProgress(0);
         }
-    }, []);
+    }, [pathOrUrl]);
     return {
         model: modelRef.current,
         isReady,

package/lib/index.d.ts

@@ -4,6 +4,7 @@ export type { ChatMessage } from "./templates";
 export { applyGemmaTemplate, applyPhiTemplate, applyLlamaTemplate, } from "./templates";
 export type { MemorySnapshot, MemoryTracker, MemoryTrackerSummary, } from "./memoryTracker";
 export { createMemoryTracker, createNativeBuffer } from "./memoryTracker";
+export type { LiteRTLMInstance } from "./modelFactory";
 export * from "./hooks";
 /**
  * Creates a new LiteRT-LM inference engine instance.

package/lib/index.js

@@ -116,12 +116,9 @@ function checkBackendSupport(backend) {
             return "NPU backend requires compatible hardware (Qualcomm Hexagon, MediaTek APU, etc.). Will fall back to GPU if unavailable.";
         }
         if (react_native_1.Platform.OS === "ios") {
-            return "NPU/CoreML is not yet supported on iOS. LiteRT-LM iOS support is pending.";
+            return "NPU (Neural Engine) is not yet supported on iOS. Use 'gpu' (Metal) or 'cpu' instead.";
         }
     }
-    if (react_native_1.Platform.OS === "ios" && backend !== "cpu") {
-        return "LiteRT-LM iOS is not yet released. Only CPU backend may work via fallback.";
-    }
     return undefined;
 }
 /**
@@ -143,7 +140,7 @@ function checkBackendSupport(backend) {
  */
 function checkMultimodalSupport() {
     if (react_native_1.Platform.OS === "ios") {
-        return "Multimodal (image/audio) is not yet supported on iOS. LiteRT-LM iOS SDK is pending.";
+        return "Multimodal (image/audio) is experimental on iOS. Vision and audio executors may not be available in the current build.";
     }
     return undefined;
 }

package/lib/memoryTracker.d.ts

@@ -3,7 +3,7 @@
  *
  * Records real memory usage from OS-level APIs via `getMemoryUsage()`,
  * and stores snapshots in a native-backed ArrayBuffer allocated via
- * `NitroModules.createNativeArrayBuffer()` (v0.34+) for zero-copy interop.
+ * `NitroModules.createNativeArrayBuffer()` (v0.35+) for zero-copy interop.
  *
  * @example
  * ```typescript

package/lib/memoryTracker.js

@@ -4,7 +4,7 @@
  *
  * Records real memory usage from OS-level APIs via `getMemoryUsage()`,
  * and stores snapshots in a native-backed ArrayBuffer allocated via
- * `NitroModules.createNativeArrayBuffer()` (v0.34+) for zero-copy interop.
+ * `NitroModules.createNativeArrayBuffer()` (v0.35+) for zero-copy interop.
  *
  * @example
  * ```typescript

package/lib/modelFactory.d.ts

@@ -1,10 +1,18 @@
-import { LiteRTLM } from "./specs/LiteRTLM.nitro";
+import { LiteRTLM, LLMConfig } from "./specs/LiteRTLM.nitro";
 import { MemoryTracker } from "./memoryTracker";
+/**
+ * Extended LiteRT-LM instance with optional memory tracking and
+ * augmented loadModel that accepts a download progress callback.
+ */
+export type LiteRTLMInstance = Omit<LiteRTLM, "loadModel"> & {
+    memoryTracker?: MemoryTracker;
+    loadModel: (pathOrUrl: string, config?: LLMConfig, onDownloadProgress?: (progress: number) => void) => Promise<void>;
+};
 /**
  * Creates a new LiteRT-LM inference engine instance.
  *
  * Optionally creates a native-backed memory tracker using
- * `NitroModules.createNativeArrayBuffer()` (v0.34+) for efficient
+ * `NitroModules.createNativeArrayBuffer()` (v0.35+) for efficient
  * zero-copy memory usage tracking.
  *
  * @param options.enableMemoryTracking Enable automatic memory tracking (default: false)
@@ -13,6 +21,4 @@ import { MemoryTracker } from "./memoryTracker";
 export declare function createLLM(options?: {
     enableMemoryTracking?: boolean;
     maxMemorySnapshots?: number;
-}): LiteRTLM & {
-    memoryTracker?: MemoryTracker;
-};
+}): LiteRTLMInstance;

package/lib/modelFactory.js

@@ -7,7 +7,7 @@ const memoryTracker_1 = require("./memoryTracker");
  * Creates a new LiteRT-LM inference engine instance.
  *
  * Optionally creates a native-backed memory tracker using
- * `NitroModules.createNativeArrayBuffer()` (v0.34+) for efficient
+ * `NitroModules.createNativeArrayBuffer()` (v0.35+) for efficient
  * zero-copy memory usage tracking.
  *
  * @param options.enableMemoryTracking Enable automatic memory tracking (default: false)
@@ -41,10 +41,15 @@ function createLLM(options) {
     return {
         ...native,
         memoryTracker: tracker,
-        loadModel: async (pathOrUrl, config) => {
+        loadModel: async (pathOrUrl, config, onDownloadProgress) => {
             let modelPath = pathOrUrl;
-            // Check if it's a URL
+            // Check if it's a URL — enforce HTTPS for model downloads
             if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+                if (pathOrUrl.startsWith("http://")) {
+                    throw new Error("Insecure HTTP URLs are not allowed for model downloads. " +
+                        "Use HTTPS instead: " +
+                        pathOrUrl.replace("http://", "https://"));
+                }
                 // Extract filename from URL
                 const fileName = pathOrUrl.split("/").pop();
                 if (!fileName) {
@@ -52,7 +57,7 @@ function createLLM(options) {
                 }
                 console.log(`Checking model at ${pathOrUrl}...`);
                 modelPath = await native.downloadModel(pathOrUrl, fileName, (progress) => {
-                    console.log(`Download progress: ${progress}`);
+                    onDownloadProgress?.(progress);
                 });
                 console.log(`Model downloaded to: ${modelPath}`);
             }

package/nitrogen/generated/android/LiteRTLMOnLoad.cpp

@@ -28,12 +28,21 @@ int initialize(JavaVM* vm) {
   });
 }
 
+struct JHybridLiteRTLMSpecImpl: public jni::JavaClass<JHybridLiteRTLMSpecImpl, JHybridLiteRTLMSpec::JavaPart> {
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM;";
+  static std::shared_ptr<JHybridLiteRTLMSpec> create() {
+    static auto constructorFn = javaClassStatic()->getConstructor<JHybridLiteRTLMSpecImpl::javaobject()>();
+    jni::local_ref<JHybridLiteRTLMSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridLiteRTLMSpec();
+  }
+};
+
 void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::litertlm;
 
   // Register native JNI methods
-  margelo::nitro::litertlm::JHybridLiteRTLMSpec::registerNatives();
+  margelo::nitro::litertlm::JHybridLiteRTLMSpec::CxxPart::registerNatives();
   margelo::nitro::litertlm::JFunc_void_double_cxx::registerNatives();
   margelo::nitro::litertlm::JFunc_void_std__string_bool_cxx::registerNatives();
 
@@ -41,9 +50,7 @@ void registerAllNatives() {
   HybridObjectRegistry::registerHybridObjectConstructor(
     "LiteRTLM",
     []() -> std::shared_ptr<HybridObject> {
-      static DefaultConstructableObject<JHybridLiteRTLMSpec::javaobject> object("com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM");
-      auto instance = object.create();
-      return instance->cthis()->shared();
+      return JHybridLiteRTLMSpecImpl::create();
     }
   );
 }

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

@@ -45,37 +45,31 @@ namespace margelo::nitro::litertlm { enum class Backend; }
 
 namespace margelo::nitro::litertlm {
 
-  jni::local_ref<JHybridLiteRTLMSpec::jhybriddata> JHybridLiteRTLMSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
-  }
-
-  void JHybridLiteRTLMSpec::registerNatives() {
-    registerHybrid({
-      makeNativeMethod("initHybrid", JHybridLiteRTLMSpec::initHybrid),
-    });
+  std::shared_ptr<JHybridLiteRTLMSpec> JHybridLiteRTLMSpec::JavaPart::getJHybridLiteRTLMSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridLiteRTLMSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridLiteRTLMSpec!");
+    }
+    return castHybridObject;
   }
 
-  size_t JHybridLiteRTLMSpec::getExternalMemorySize() noexcept {
-    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
-    return method(_javaPart);
+  jni::local_ref<JHybridLiteRTLMSpec::CxxPart::jhybriddata> JHybridLiteRTLMSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
   }
 
-  bool JHybridLiteRTLMSpec::equals(const std::shared_ptr<HybridObject>& other) {
-    if (auto otherCast = std::dynamic_pointer_cast<JHybridLiteRTLMSpec>(other)) {
-      return _javaPart == otherCast->_javaPart;
+  std::shared_ptr<JHybridObject> JHybridLiteRTLMSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridLiteRTLMSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridLiteRTLMSpec::JavaPart!");
     }
-    return false;
-  }
-
-  void JHybridLiteRTLMSpec::dispose() noexcept {
-    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
-    method(_javaPart);
+    return std::make_shared<JHybridLiteRTLMSpec>(castJavaPart);
   }
 
-  std::string JHybridLiteRTLMSpec::toString() {
-    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
-    auto javaString = method(_javaPart);
-    return javaString->toStdString();
+  void JHybridLiteRTLMSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridLiteRTLMSpec::CxxPart::initHybrid),
+    });
   }
 
   // Properties
@@ -83,7 +77,7 @@ namespace margelo::nitro::litertlm {
 
   // Methods
   std::shared_ptr<Promise<void>> JHybridLiteRTLMSpec::loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* modelPath */, jni::alias_ref<JLLMConfig> /* config */)>("loadModel");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* modelPath */, jni::alias_ref<JLLMConfig> /* config */)>("loadModel");
     auto __result = method(_javaPart, jni::make_jstring(modelPath), config.has_value() ? JLLMConfig::fromCpp(config.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<void>::create();
@@ -98,7 +92,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessage(const std::string& message) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
     auto __result = method(_javaPart, jni::make_jstring(message));
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -114,7 +108,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessageWithImage(const std::string& message, const std::string& imagePath) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* imagePath */)>("sendMessageWithImage");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* imagePath */)>("sendMessageWithImage");
     auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(imagePath));
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -130,7 +124,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::downloadModel(const std::string& url, const std::string& fileName, const std::optional<std::function<void(double /* progress */)>>& onProgress) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JString> /* fileName */, jni::alias_ref<JFunc_void_double::javaobject> /* onProgress */)>("downloadModel_cxx");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JString> /* fileName */, jni::alias_ref<JFunc_void_double::javaobject> /* onProgress */)>("downloadModel_cxx");
     auto __result = method(_javaPart, jni::make_jstring(url), jni::make_jstring(fileName), onProgress.has_value() ? JFunc_void_double_cxx::fromCpp(onProgress.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -146,7 +140,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<void>> JHybridLiteRTLMSpec::deleteModel(const std::string& fileName) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* fileName */)>("deleteModel");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* fileName */)>("deleteModel");
     auto __result = method(_javaPart, jni::make_jstring(fileName));
     return [&]() {
       auto __promise = Promise<void>::create();
@@ -161,7 +155,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessageWithAudio(const std::string& message, const std::string& audioPath) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
     auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(audioPath));
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -177,11 +171,11 @@ namespace margelo::nitro::litertlm {
     }();
   }
   void JHybridLiteRTLMSpec::sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");
     method(_javaPart, jni::make_jstring(message), JFunc_void_std__string_bool_cxx::fromCpp(onToken));
   }
   std::vector<Message> JHybridLiteRTLMSpec::getHistory() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMessage>>()>("getHistory");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMessage>>()>("getHistory");
     auto __result = method(_javaPart);
     return [&]() {
       size_t __size = __result->size();
@@ -195,26 +189,26 @@ namespace margelo::nitro::litertlm {
     }();
   }
   void JHybridLiteRTLMSpec::resetConversation() {
-    static const auto method = javaClassStatic()->getMethod<void()>("resetConversation");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("resetConversation");
     method(_javaPart);
   }
   bool JHybridLiteRTLMSpec::isReady() {
-    static const auto method = javaClassStatic()->getMethod<jboolean()>("isReady");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isReady");
     auto __result = method(_javaPart);
     return static_cast<bool>(__result);
   }
   GenerationStats JHybridLiteRTLMSpec::getStats() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JGenerationStats>()>("getStats");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JGenerationStats>()>("getStats");
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
   MemoryUsage JHybridLiteRTLMSpec::getMemoryUsage() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JMemoryUsage>()>("getMemoryUsage");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JMemoryUsage>()>("getMemoryUsage");
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
   void JHybridLiteRTLMSpec::close() {
-    static const auto method = javaClassStatic()->getMethod<void()>("close");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("close");
     method(_javaPart);
   }