llama-cpp-pro 0.2.2

package/android/src/main/java/ai/annadata/plugin/capacitor/ModelAdmissionController.java

@@ -0,0 +1,214 @@
+package ai.annadata.plugin.capacitor;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.util.Log;
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Memory admission control for native model loading on Android.
+ *
+ * <p>This mirrors the Web/WASM {@code DefaultModelScheduler} + {@code wasmMemoryPolicy}
+ * so that all three platforms share the same isomorphic admission semantics:
+ * <ul>
+ *   <li>A hard cap on concurrent loaded models (parity with WASM_MAX_CONCURRENT_MODELS = 5).</li>
+ *   <li>Per-model footprint estimation based on GGUF file size.</li>
+ *   <li>A device-memory guard that keeps a reserve free after each load.</li>
+ * </ul>
+ *
+ * <p>Unlike the Web path (bounded by a single 2 GB WASM linear-memory pool), the native
+ * ceiling is the device's available RAM as reported by {@link ActivityManager}. The class
+ * therefore rejects a load when either the slot limit is reached or the projected free
+ * memory after loading would fall below the reserve threshold.
+ */
+final class ModelAdmissionController {
+    private static final String TAG = "ModelAdmission";
+
+    /** Max concurrent native contexts. Parity with WASM_MAX_CONCURRENT_MODELS. */
+    static final int MAX_CONCURRENT_MODELS = 5;
+
+    /** Keep this much device RAM free after a model load (headroom for the app + OS). */
+    static final long DEFAULT_RESERVE_BYTES = 512L * 1024 * 1024; // 512 MB
+
+    /** Fallback footprint when the GGUF size cannot be determined. */
+    private static final long UNKNOWN_MODEL_FOOTPRINT_BYTES = 512L * 1024 * 1024;
+
+    enum DeniedBy { LIMIT, MEMORY }
+
+    /** Result of an admission decision. */
+    static final class Decision {
+        final boolean allow;
+        final DeniedBy deniedBy;      // null when allowed
+        final String reason;          // null when allowed
+        final long estimatedBytes;
+
+        private Decision(boolean allow, DeniedBy deniedBy, String reason, long estimatedBytes) {
+            this.allow = allow;
+            this.deniedBy = deniedBy;
+            this.reason = reason;
+            this.estimatedBytes = estimatedBytes;
+        }
+
+        static Decision allowed(long estimatedBytes) {
+            return new Decision(true, null, null, estimatedBytes);
+        }
+
+        static Decision denied(DeniedBy deniedBy, String reason, long estimatedBytes) {
+            return new Decision(false, deniedBy, reason, estimatedBytes);
+        }
+    }
+
+    /** Lightweight snapshot of device memory (mirrors the Web MemorySnapshot). */
+    static final class MemorySnapshot {
+        final long totalBytes;
+        final long freeBytes;
+        final boolean lowMemory;
+
+        MemorySnapshot(long totalBytes, long freeBytes, boolean lowMemory) {
+            this.totalBytes = totalBytes;
+            this.freeBytes = freeBytes;
+            this.lowMemory = lowMemory;
+        }
+    }
+
+    private final Context appContext;
+    private final int maxModels;
+    private final long reserveBytes;
+
+    ModelAdmissionController(Context appContext) {
+        this(appContext, MAX_CONCURRENT_MODELS, DEFAULT_RESERVE_BYTES);
+    }
+
+    ModelAdmissionController(Context appContext, int maxModels, long reserveBytes) {
+        this.appContext = appContext;
+        this.maxModels = maxModels;
+        this.reserveBytes = reserveBytes;
+    }
+
+    /**
+     * Estimate the resident footprint of a model once loaded.
+     *
+     * <p>Native loading (mmap or full read) does not duplicate the GGUF the way a naive
+     * heap copy would, but the KV cache and compute buffers add headroom on top of the
+     * mapped weights. The multipliers below match the WASM policy's intent, scaled for
+     * native memory behaviour.
+     *
+     * @param fileBytes  GGUF file size in bytes (0 or negative when unknown)
+     * @param embedding  whether the context is an embedding-only model (lighter headroom)
+     */
+    static long estimateModelFootprint(long fileBytes, boolean embedding) {
+        if (fileBytes <= 0) {
+            return UNKNOWN_MODEL_FOOTPRINT_BYTES;
+        }
+        // Weights (mapped) + a proportional slice for KV cache / compute buffers.
+        double weightMultiplier;
+        if (embedding) {
+            weightMultiplier = 1.15;
+        } else if (fileBytes > 200L * 1024 * 1024) {
+            weightMultiplier = 1.30;
+        } else {
+            weightMultiplier = 1.20;
+        }
+        long proportionalHeadroom = (long) Math.ceil(fileBytes * 0.12);
+        long minHeadroom = embedding ? 48L * 1024 * 1024 : 96L * 1024 * 1024;
+        long headroom = Math.max(minHeadroom, proportionalHeadroom);
+        return (long) Math.ceil(fileBytes * weightMultiplier) + headroom;
+    }
+
+    /** Read the GGUF file size, returning 0 when the path is missing or unreadable. */
+    static long fileSizeBytes(String modelPath) {
+        if (modelPath == null || modelPath.isEmpty()) {
+            return 0L;
+        }
+        try {
+            File f = new File(modelPath);
+            return f.exists() ? f.length() : 0L;
+        } catch (Exception e) {
+            return 0L;
+        }
+    }
+
+    /** Capture a device memory snapshot from {@link ActivityManager}. */
+    MemorySnapshot memorySnapshot() {
+        try {
+            ActivityManager am = (ActivityManager) appContext.getSystemService(Context.ACTIVITY_SERVICE);
+            if (am == null) {
+                return new MemorySnapshot(0L, 0L, false);
+            }
+            ActivityManager.MemoryInfo info = new ActivityManager.MemoryInfo();
+            am.getMemoryInfo(info);
+            return new MemorySnapshot(info.totalMem, info.availMem, info.lowMemory);
+        } catch (Exception e) {
+            Log.w(TAG, "Failed to read memory snapshot: " + e.getMessage());
+            return new MemorySnapshot(0L, 0L, false);
+        }
+    }
+
+    /**
+     * Decide whether a new model may be admitted.
+     *
+     * @param currentlyLoaded number of contexts already loaded
+     * @param modelPath       path to the GGUF being loaded (used to size the footprint)
+     * @param embedding       whether this is an embedding-only context
+     */
+    Decision canAdmit(int currentlyLoaded, String modelPath, boolean embedding) {
+        long fileBytes = fileSizeBytes(modelPath);
+        long estimated = estimateModelFootprint(fileBytes, embedding);
+
+        // 1. Slot limit (parity with Web).
+        if (currentlyLoaded >= maxModels) {
+            return Decision.denied(
+                DeniedBy.LIMIT,
+                "Model slot limit reached (" + maxModels + " concurrent contexts)",
+                estimated
+            );
+        }
+
+        // 2. Device-memory guard: keep `reserveBytes` free after the load.
+        MemorySnapshot mem = memorySnapshot();
+        if (mem.lowMemory) {
+            return Decision.denied(
+                DeniedBy.MEMORY,
+                "Device reported low-memory state; refusing to load model",
+                estimated
+            );
+        }
+        if (mem.freeBytes > 0) {
+            long projectedFree = mem.freeBytes - estimated;
+            if (projectedFree < reserveBytes) {
+                return Decision.denied(
+                    DeniedBy.MEMORY,
+                    "Insufficient memory: need ~" + toMb(estimated) + " MB, "
+                        + toMb(mem.freeBytes) + " MB free, "
+                        + toMb(reserveBytes) + " MB reserve required",
+                    estimated
+                );
+            }
+        }
+
+        return Decision.allowed(estimated);
+    }
+
+    /** Snapshot of admission state for diagnostics / health reporting. */
+    Map<String, Object> status(int currentlyLoaded) {
+        MemorySnapshot mem = memorySnapshot();
+        Map<String, Object> m = new HashMap<>();
+        m.put("loadedModels", currentlyLoaded);
+        m.put("maxModels", maxModels);
+        m.put("deviceTotalBytes", mem.totalBytes);
+        m.put("deviceFreeBytes", mem.freeBytes);
+        m.put("reserveBytes", reserveBytes);
+        m.put("lowMemory", mem.lowMemory);
+        return m;
+    }
+
+    int maxModels() {
+        return maxModels;
+    }
+
+    private static long toMb(long bytes) {
+        return bytes / (1024 * 1024);
+    }
+}

package/android/src/main/jni-chat-session.cpp

@@ -0,0 +1,261 @@
+// Advanced Chat and Session Management Methods for Android JNI
+
+// MARK: - Advanced Chat Methods
+
+JNIEXPORT jobject JNICALL
+Java_ai_annadata_plugin_capacitor_LlamaCpp_chatNative(
+    JNIEnv* env, jobject thiz, jlong contextId, jobjectArray messages_array, 
+    jstring system, jstring chat_template, jobject params) {
+    
+    try {
+        LOGI("Chat completion for context ID: %ld", contextId);
+        
+        auto it = contexts.find(contextId);
+        if (it == contexts.end()) {
+            LOGE("Context not found: %ld", contextId);
+            throw_java_exception(env, "java/lang/RuntimeException", "Context not found");
+            return nullptr;
+        }
+        
+        auto& ctx = it->second;
+        if (!ctx || !ctx->ctx) {
+            LOGE("Invalid context");
+            throw_java_exception(env, "java/lang/RuntimeException", "Invalid context");
+            return nullptr;
+        }
+        
+        // Convert Java messages array to JSON
+        jsize messages_length = env->GetArrayLength(messages_array);
+        std::string messages_json = "[";
+        
+        for (jsize i = 0; i < messages_length; i++) {
+            jobject msg_obj = env->GetObjectArrayElement(messages_array, i);
+            jclass hashMapClass = env->GetObjectClass(msg_obj);
+            jmethodID getMethod = env->GetMethodID(hashMapClass, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
+            
+            // Get role
+            jstring roleKey = jni_utils::string_to_jstring(env, "role");
+            jstring roleValue = (jstring)env->CallObjectMethod(msg_obj, getMethod, roleKey);
+            std::string role = jni_utils::jstring_to_string(env, roleValue);
+            env->DeleteLocalRef(roleKey);
+            env->DeleteLocalRef(roleValue);
+            
+            // Get content
+            jstring contentKey = jni_utils::string_to_jstring(env, "content");
+            jstring contentValue = (jstring)env->CallObjectMethod(msg_obj, getMethod, contentKey);
+            std::string content = jni_utils::jstring_to_string(env, contentValue);
+            env->DeleteLocalRef(contentKey);
+            env->DeleteLocalRef(contentValue);
+            
+            if (i > 0) messages_json += ",";
+            messages_json += "{\"role\":\"" + role + "\",\"content\":\"" + content + "\"}";
+            
+            env->DeleteLocalRef(msg_obj);
+        }
+        
+        messages_json += "]";
+        
+        std::string system_str = jni_utils::jstring_to_string(env, system);
+        std::string template_str = jni_utils::jstring_to_string(env, chat_template);
+        
+        LOGI("Chat messages: %s", messages_json.c_str());
+        LOGI("System prompt: %s", system_str.c_str());
+        
+        // Format chat prompt
+        std::string formatted_prompt = ctx->getFormattedChat(messages_json, template_str);
+        
+        // Extract completion parameters
+        jint n_predict = 512;
+        jdouble temperature = 0.7;
+        
+        if (params != nullptr) {
+            jclass jsObjectClass = env->GetObjectClass(params);
+            jmethodID getIntegerMethod = env->GetMethodID(jsObjectClass, "getInteger", "(Ljava/lang/String;)Ljava/lang/Integer;");
+            if (env->ExceptionCheck()) {
+                env->ExceptionClear();
+                getIntegerMethod = nullptr;
+            }
+
+            if (getIntegerMethod != nullptr) {
+                jstring key = jni_utils::string_to_jstring(env, "n_predict");
+                jobject val = env->CallObjectMethod(params, getIntegerMethod, key);
+                if (val != nullptr && !env->ExceptionCheck()) {
+                    n_predict = env->CallIntMethod(val, env->GetMethodID(env->FindClass("java/lang/Integer"), "intValue", "()I"));
+                    env->DeleteLocalRef(val);
+                } else if (env->ExceptionCheck()) {
+                    env->ExceptionClear();
+                }
+                env->DeleteLocalRef(key);
+            }
+
+            temperature = jni_utils::jsobject_opt_double(env, params, "temperature", temperature);
+        }
+        
+        // Run completion with formatted prompt
+        ctx->params.n_predict = n_predict;
+        ctx->params.sampling.temp = temperature;
+        
+        // This would delegate to the completion method
+        // For now, return formatted prompt
+        jclass hashMapClass = env->FindClass("java/util/HashMap");
+        jmethodID hashMapConstructor = env->GetMethodID(hashMapClass, "<init>", "()V");
+        jmethodID putMethod = env->GetMethodID(hashMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+        
+        jobject resultMap = env->NewObject(hashMapClass, hashMapConstructor);
+        
+        env->CallObjectMethod(resultMap, putMethod,
+            jni_utils::string_to_jstring(env, "formatted_prompt"),
+            jni_utils::string_to_jstring(env, formatted_prompt));
+        
+        return resultMap;
+        
+    } catch (const std::exception& e) {
+        LOGE("Exception in chat: %s", e.what());
+        throw_java_exception(env, "java/lang/RuntimeException", e.what());
+        return nullptr;
+    }
+}
+
+JNIEXPORT jobject JNICALL
+Java_ai_annadata_plugin_capacitor_LlamaCpp_chatWithSystemNative(
+    JNIEnv* env, jobject thiz, jlong contextId, jstring system, jstring message, jobject params) {
+    
+    try {
+        LOGI("Chat with system for context ID: %ld", contextId);
+        
+        auto it = contexts.find(contextId);
+        if (it == contexts.end()) {
+            LOGE("Context not found: %ld", contextId);
+            throw_java_exception(env, "java/lang/RuntimeException", "Context not found");
+            return nullptr;
+        }
+        
+        auto& ctx = it->second;
+        if (!ctx || !ctx->ctx) {
+            LOGE("Invalid context");
+            throw_java_exception(env, "java/lang/RuntimeException", "Invalid context");
+            return nullptr;
+        }
+        
+        std::string system_str = jni_utils::jstring_to_string(env, system);
+        std::string message_str = jni_utils::jstring_to_string(env, message);
+        
+        LOGI("System: %s", system_str.c_str());
+        LOGI("Message: %s", message_str.c_str());
+        
+        // Build messages array
+        std::string messages_json = "[";
+        messages_json += "{\"role\":\"system\",\"content\":\"" + system_str + "\"},";
+        messages_json += "{\"role\":\"user\",\"content\":\"" + message_str + "\"}";
+        messages_json += "]";
+        
+        // Format using default chat template
+        std::string formatted_prompt = ctx->getFormattedChat(messages_json, "");
+        
+        LOGI("Formatted prompt length: %zu", formatted_prompt.length());
+        
+        // Return formatted prompt in result map
+        jclass hashMapClass = env->FindClass("java/util/HashMap");
+        jmethodID hashMapConstructor = env->GetMethodID(hashMapClass, "<init>", "()V");
+        jmethodID putMethod = env->GetMethodID(hashMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+        
+        jobject resultMap = env->NewObject(hashMapClass, hashMapConstructor);
+        
+        env->CallObjectMethod(resultMap, putMethod,
+            jni_utils::string_to_jstring(env, "formatted_prompt"),
+            jni_utils::string_to_jstring(env, formatted_prompt));
+        
+        return resultMap;
+        
+    } catch (const std::exception& e) {
+        LOGE("Exception in chatWithSystem: %s", e.what());
+        throw_java_exception(env, "java/lang/RuntimeException", e.what());
+        return nullptr;
+    }
+}
+
+JNIEXPORT jobject JNICALL
+Java_ai_annadata_plugin_capacitor_LlamaCpp_generateTextNative(
+    JNIEnv* env, jobject thiz, jlong contextId, jstring prompt, jobject params) {
+    
+    try {
+        LOGI("Generate text for context ID: %ld", contextId);
+        
+        auto it = contexts.find(contextId);
+        if (it == contexts.end()) {
+            LOGE("Context not found: %ld", contextId);
+            throw_java_exception(env, "java/lang/RuntimeException", "Context not found");
+            return nullptr;
+        }
+        
+        auto& ctx = it->second;
+        if (!ctx || !ctx->ctx) {
+            LOGE("Invalid context");
+            throw_java_exception(env, "java/lang/RuntimeException", "Invalid context");
+            return nullptr;
+        }
+        
+        std::string prompt_str = jni_utils::jstring_to_string(env, prompt);
+        
+        // Extract parameters
+        jint n_predict = 256;
+        jdouble temperature = 0.7;
+        
+        if (params != nullptr) {
+            jclass jsObjectClass = env->GetObjectClass(params);
+            jmethodID getIntegerMethod = env->GetMethodID(jsObjectClass, "getInteger", "(Ljava/lang/String;)Ljava/lang/Integer;");
+            if (env->ExceptionCheck()) {
+                env->ExceptionClear();
+                getIntegerMethod = nullptr;
+            }
+
+            if (getIntegerMethod != nullptr) {
+                jstring key = jni_utils::string_to_jstring(env, "n_predict");
+                jobject val = env->CallObjectMethod(params, getIntegerMethod, key);
+                if (val != nullptr && !env->ExceptionCheck()) {
+                    n_predict = env->CallIntMethod(val, env->GetMethodID(env->FindClass("java/lang/Integer"), "intValue", "()I"));
+                    env->DeleteLocalRef(val);
+                } else if (env->ExceptionCheck()) {
+                    env->ExceptionClear();
+                }
+                env->DeleteLocalRef(key);
+            }
+
+            temperature = jni_utils::jsobject_opt_double(env, params, "temperature", temperature);
+        }
+        
+        LOGI("Generate text prompt: %s, n_predict: %d", prompt_str.c_str(), n_predict);
+        
+        // Set generation parameters
+        ctx->params.n_predict = n_predict;
+        ctx->params.sampling.temp = temperature;
+        
+        // This would delegate to completion
+        jclass hashMapClass = env->FindClass("java/util/HashMap");
+        jmethodID hashMapConstructor = env->GetMethodID(hashMapClass, "<init>", "()V");
+        jmethodID putMethod = env->GetMethodID(hashMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+        
+        jobject resultMap = env->NewObject(hashMapClass, hashMapConstructor);
+        
+        env->CallObjectMethod(resultMap, putMethod,
+            jni_utils::string_to_jstring(env, "prompt"),
+            jni_utils::string_to_jstring(env, prompt_str));
+        
+        env->CallObjectMethod(resultMap, putMethod,
+            jni_utils::string_to_jstring(env, "n_predict"),
+            env->NewObject(env->FindClass("java/lang/Integer"),
+                env->GetMethodID(env->FindClass("java/lang/Integer"), "<init>", "(I)V"),
+                n_predict));
+        
+        return resultMap;
+        
+    } catch (const std::exception& e) {
+        LOGE("Exception in generateText: %s", e.what());
+        throw_java_exception(env, "java/lang/RuntimeException", e.what());
+        return nullptr;
+    }
+}
+
+// MARK: - Session Management Methods
+// NOTE: loadSessionNative and saveSessionNative are implemented in jni.cpp
+// with full llama_state_save/load_file support. Stubs removed to avoid redefinition.

package/android/src/main/jni-lora.cpp

@@ -0,0 +1,197 @@
+// LoRA Adapter Methods for Android JNI
+// Note: These are defined as _impl variants; the public JNI entry points in
+// jni.cpp forward to them. This avoids duplicate-symbol conflicts at link time.
+
+JNIEXPORT jint JNICALL
+Java_ai_annadata_plugin_capacitor_LlamaCpp_applyLoraAdaptersNative_impl(
+    JNIEnv* env, jobject thiz, jlong contextId, jobjectArray loraAdaptersArray) {
+    
+    try {
+        LOGI("Applying LoRA adapters for context ID: %ld", contextId);
+        
+        // Find the context
+        auto it = contexts.find(contextId);
+        if (it == contexts.end()) {
+            LOGE("Context not found: %ld", contextId);
+            throw_java_exception(env, "java/lang/RuntimeException", "Context not found");
+            return -1;
+        }
+        
+        auto& ctx = it->second;
+        if (!ctx || !ctx->ctx || !ctx->model) {
+            LOGE("Invalid context, llama context, or model is null");
+            throw_java_exception(env, "java/lang/RuntimeException", "Invalid context or model not loaded");
+            return -1;
+        }
+        
+        // Convert Java array of HashMap to C++ vector of LoRA info
+        std::vector<common_adapter_lora_info> lora_adapters;
+        
+        if (loraAdaptersArray != nullptr) {
+            jsize array_length = env->GetArrayLength(loraAdaptersArray);
+            LOGI("Processing %d LoRA adapters", array_length);
+            
+            for (jsize i = 0; i < array_length; i++) {
+                jobject adapter_obj = env->GetObjectArrayElement(loraAdaptersArray, i);
+                if (adapter_obj == nullptr) {
+                    LOGW("LoRA adapter at index %d is null", i);
+                    continue;
+                }
+                
+                // Get HashMap class
+                jclass hashMapClass = env->GetObjectClass(adapter_obj);
+                jmethodID getMethod = env->GetMethodID(hashMapClass, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
+                
+                // Get path from HashMap
+                jstring pathKey = jni_utils::string_to_jstring(env, "path");
+                jstring pathValue = (jstring)env->CallObjectMethod(adapter_obj, getMethod, pathKey);
+                env->DeleteLocalRef(pathKey);
+                
+                if (pathValue == nullptr) {
+                    LOGE("LoRA adapter at index %d has no path", i);
+                    env->DeleteLocalRef(adapter_obj);
+                    continue;
+                }
+                
+                std::string path = jni_utils::jstring_to_string(env, pathValue);
+                env->DeleteLocalRef(pathValue);
+                
+                // Get scale from HashMap if provided
+                float scale = 1.0f;
+                jstring scaleKey = jni_utils::string_to_jstring(env, "scale");
+                jobject scaleValue = env->CallObjectMethod(adapter_obj, getMethod, scaleKey);
+                env->DeleteLocalRef(scaleKey);
+                
+                if (scaleValue != nullptr) {
+                    jclass doubleClass = env->FindClass("java/lang/Double");
+                    jmethodID doubleValueMethod = env->GetMethodID(doubleClass, "doubleValue", "()D");
+                    scale = static_cast<float>(env->CallDoubleMethod(scaleValue, doubleValueMethod));
+                    env->DeleteLocalRef(scaleValue);
+                    LOGI("LoRA adapter %d scale: %.2f", i, scale);
+                }
+                
+                // Create LoRA info struct
+                common_adapter_lora_info lora_info;
+                lora_info.path = path;
+                lora_info.scale = scale;
+                lora_adapters.push_back(lora_info);
+                
+                LOGI("LoRA adapter %d added: path=%s, scale=%.2f", i, path.c_str(), scale);
+                env->DeleteLocalRef(adapter_obj);
+            }
+        }
+        
+        // Apply LoRA adapters
+        LOGI("Calling applyLoraAdapters with %zu adapters", lora_adapters.size());
+        int result = ctx->applyLoraAdapters(lora_adapters);
+        
+        if (result != 0) {
+            LOGE("Failed to apply LoRA adapters: %d", result);
+            throw_java_exception(env, "java/lang/RuntimeException", "Failed to apply LoRA adapters");
+            return -1;
+        }
+        
+        LOGI("LoRA adapters applied successfully");
+        return static_cast<jint>(lora_adapters.size());
+        
+    } catch (const std::exception& e) {
+        LOGE("Exception in applyLoraAdapters: %s", e.what());
+        throw_java_exception(env, "java/lang/RuntimeException", e.what());
+        return -1;
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_ai_annadata_plugin_capacitor_LlamaCpp_removeLoraAdaptersNative_impl(
+    JNIEnv* env, jobject thiz, jlong contextId) {
+    
+    try {
+        LOGI("Removing LoRA adapters for context ID: %ld", contextId);
+        
+        auto it = contexts.find(contextId);
+        if (it == contexts.end()) {
+            LOGE("Context not found: %ld", contextId);
+            throw_java_exception(env, "java/lang/RuntimeException", "Context not found");
+            return;
+        }
+        
+        auto& ctx = it->second;
+        if (!ctx || !ctx->ctx) {
+            LOGE("Invalid context or llama context is null");
+            throw_java_exception(env, "java/lang/RuntimeException", "Invalid context");
+            return;
+        }
+        
+        ctx->removeLoraAdapters();
+        LOGI("LoRA adapters removed successfully");
+        
+    } catch (const std::exception& e) {
+        LOGE("Exception in removeLoraAdapters: %s", e.what());
+        throw_java_exception(env, "java/lang/RuntimeException", e.what());
+    }
+}
+
+JNIEXPORT jobject JNICALL
+Java_ai_annadata_plugin_capacitor_LlamaCpp_getLoadedLoraAdaptersNative_impl(
+    JNIEnv* env, jobject thiz, jlong contextId) {
+    
+    try {
+        LOGI("Getting loaded LoRA adapters for context ID: %ld", contextId);
+        
+        auto it = contexts.find(contextId);
+        if (it == contexts.end()) {
+            LOGE("Context not found: %ld", contextId);
+            throw_java_exception(env, "java/lang/RuntimeException", "Context not found");
+            return nullptr;
+        }
+        
+        auto& ctx = it->second;
+        if (!ctx || !ctx->ctx) {
+            LOGE("Invalid context or llama context is null");
+            throw_java_exception(env, "java/lang/RuntimeException", "Invalid context");
+            return nullptr;
+        }
+        
+        // Get loaded adapters
+        std::vector<common_adapter_lora_info> adapters = ctx->getLoadedLoraAdapters();
+        
+        // Create Java ArrayList for result
+        jclass arrayListClass = env->FindClass("java/util/ArrayList");
+        jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "<init>", "()V");
+        jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");
+        
+        jobject resultList = env->NewObject(arrayListClass, arrayListConstructor);
+        
+        // Add each adapter to ArrayList
+        jclass hashMapClass = env->FindClass("java/util/HashMap");
+        jmethodID hashMapConstructor = env->GetMethodID(hashMapClass, "<init>", "()V");
+        jmethodID putMethod = env->GetMethodID(hashMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+        
+        for (const auto& adapter : adapters) {
+            jobject adapterMap = env->NewObject(hashMapClass, hashMapConstructor);
+            
+            env->CallObjectMethod(adapterMap, putMethod,
+                jni_utils::string_to_jstring(env, "path"),
+                jni_utils::string_to_jstring(env, adapter.path));
+            
+            env->CallObjectMethod(adapterMap, putMethod,
+                jni_utils::string_to_jstring(env, "scale"),
+                env->NewObject(env->FindClass("java/lang/Double"),
+                    env->GetMethodID(env->FindClass("java/lang/Double"), "<init>", "(D)V"),
+                    static_cast<jdouble>(adapter.scale)));
+            
+            env->CallBooleanMethod(resultList, addMethod, adapterMap);
+            env->DeleteLocalRef(adapterMap);
+            
+            LOGI("LoRA adapter: path=%s, scale=%.2f", adapter.path.c_str(), adapter.scale);
+        }
+        
+        LOGI("Retrieved %zu loaded LoRA adapters", adapters.size());
+        return resultList;
+        
+    } catch (const std::exception& e) {
+        LOGE("Exception in getLoadedLoraAdapters: %s", e.what());
+        throw_java_exception(env, "java/lang/RuntimeException", e.what());
+        return nullptr;
+    }
+}