llama-cpp-capacitor 0.0.10 → 0.0.12

package/android/src/main/jni.cpp

@@ -3,6 +3,7 @@
 #include <android/log.h>
 #include <cstring>
 #include <memory>
+#include <fstream> // Added for file existence and size checks
 
 // Add missing symbol
 namespace rnllama {
@@ -139,13 +140,73 @@ Java_ai_annadata_plugin_capacitor_LlamaCpp_initContextNative(
     
     try {
         std::string model_path_str = jstring_to_string(env, model_path);
+        LOGI("Attempting to load model from path: %s", model_path_str.c_str());
+
+        // List all possible paths we should check
+        std::vector<std::string> paths_to_check = {
+            model_path_str,
+            "/data/data/ai.annadata.app/files/" + model_path_str,
+            "/data/data/ai.annadata.app/files/Documents/" + model_path_str,
+            "/storage/emulated/0/Android/data/ai.annadata.app/files/" + model_path_str,
+            "/storage/emulated/0/Android/data/ai.annadata.app/files/Documents/" + model_path_str,
+            "/storage/emulated/0/Documents/" + model_path_str
+        };
+
+        // Check each path and log what we find
+        std::string full_model_path;
+        bool file_found = false;
         
+        for (const auto& path : paths_to_check) {
+            LOGI("Checking path: %s", path.c_str());
+            std::ifstream file_check(path);
+            if (file_check.good()) {
+                file_check.seekg(0, std::ios::end);
+                std::streamsize file_size = file_check.tellg();
+                file_check.close();
+                LOGI("Found file at: %s, size: %ld bytes", path.c_str(), file_size);
+                
+                // Validate file size
+                if (file_size < 1024 * 1024) { // Less than 1MB
+                    LOGE("Model file is too small, likely corrupted: %s", path.c_str());
+                    continue; // Try next path
+                }
+                
+                // Check if it's a valid GGUF file by reading the magic number
+                std::ifstream magic_file(path, std::ios::binary);
+                if (magic_file.good()) {
+                    char magic[4];
+                    if (magic_file.read(magic, 4)) {
+                        if (magic[0] == 'G' && magic[1] == 'G' && magic[2] == 'U' && magic[3] == 'F') {
+                            LOGI("Valid GGUF file detected at: %s", path.c_str());
+                            full_model_path = path;
+                            file_found = true;
+                            break;
+                        } else {
+                            LOGI("File does not appear to be a GGUF file (magic: %c%c%c%c) at: %s", 
+                                 magic[0], magic[1], magic[2], magic[3], path.c_str());
+                        }
+                    }
+                    magic_file.close();
+                }
+            } else {
+                LOGI("File not found at: %s", path.c_str());
+            }
+            file_check.close();
+        }
+
+        if (!file_found) {
+            LOGE("Model file not found in any of the checked paths");
+            throw_java_exception(env, "java/lang/RuntimeException", "Model file not found in any expected location");
+            return -1;
+        }
+
         // Create new context
         auto context = std::make_unique<rnllama::llama_rn_context>();
+        LOGI("Created llama_rn_context");
         
         // Initialize common parameters
         common_params cparams;
-        cparams.model.path = model_path_str;
+        cparams.model.path = full_model_path;
         cparams.n_ctx = 2048;
         cparams.n_batch = 512;
         cparams.n_gpu_layers = 0;
@@ -199,42 +260,104 @@ Java_ai_annadata_plugin_capacitor_LlamaCpp_initContextNative(
         cparams.ubatch_size = 512;
         cparams.ubatch_seq_len_max = 1;
         
-        // Load model
-        LOGI("Attempting to load model from: %s", model_path_str.c_str());
+        LOGI("Initialized common parameters, attempting to load model from: %s", full_model_path.c_str());
         LOGI("Model parameters: n_ctx=%d, n_batch=%d, n_gpu_layers=%d", 
              cparams.n_ctx, cparams.n_batch, cparams.n_gpu_layers);
         
-        // Try to load the model
-        bool load_success = context->loadModel(cparams);
+        // Try to load the model with error handling
+        bool load_success = false;
+        try {
+            load_success = context->loadModel(cparams);
+        } catch (const std::exception& e) {
+            LOGE("Exception during model loading: %s", e.what());
+            load_success = false;
+        } catch (...) {
+            LOGE("Unknown exception during model loading");
+            load_success = false;
+        }
+        
         if (!load_success) {
-            LOGE("Model loading failed for: %s", model_path_str.c_str());
+            LOGE("context->loadModel() returned false - model loading failed");
             
             // Try with minimal parameters as fallback
             LOGI("Trying with minimal parameters...");
             common_params minimal_params;
-            minimal_params.model.path = model_path_str;
+            minimal_params.model.path = full_model_path;
             minimal_params.n_ctx = 512;
             minimal_params.n_batch = 256;
             minimal_params.n_gpu_layers = 0;
             minimal_params.use_mmap = true;
             minimal_params.use_mlock = false;
             minimal_params.numa = LM_GGML_NUMA_STRATEGY_DISABLED;
+            minimal_params.ctx_shift = false;
+            minimal_params.chat_template = "";
+            minimal_params.embedding = false;
+            minimal_params.cont_batching = false;
+            minimal_params.parallel = false;
+            minimal_params.grammar = "";
+            minimal_params.grammar_penalty.clear();
+            minimal_params.antiprompt.clear();
+            minimal_params.lora_adapter.clear();
+            minimal_params.lora_base = "";
+            minimal_params.mul_mat_q = true;
+            minimal_params.f16_kv = true;
+            minimal_params.logits_all = false;
+            minimal_params.vocab_only = false;
+            minimal_params.rope_scaling_type = LLAMA_ROPE_SCALING_TYPE_UNSPECIFIED;
+            minimal_params.rope_scaling_factor = 0.0f;
+            minimal_params.rope_scaling_orig_ctx_len = 0;
+            minimal_params.yarn_ext_factor = -1.0f;
+            minimal_params.yarn_attn_factor = 1.0f;
+            minimal_params.yarn_beta_fast = 32.0f;
+            minimal_params.yarn_beta_slow = 1.0f;
+            minimal_params.yarn_orig_ctx = 0;
+            minimal_params.offload_kqv = true;
+            minimal_params.flash_attn = false;
+            minimal_params.flash_attn_kernel = false;
+            minimal_params.flash_attn_causal = true;
+            minimal_params.mmproj = "";
+            minimal_params.image = "";
+            minimal_params.export = "";
+            minimal_params.export_path = "";
+            minimal_params.seed = -1;
+            minimal_params.n_keep = 0;
+            minimal_params.n_discard = -1;
+            minimal_params.n_draft = 0;
+            minimal_params.n_chunks = -1;
+            minimal_params.n_parallel = 1;
+            minimal_params.n_sequences = 1;
+            minimal_params.p_accept = 0.5f;
+            minimal_params.p_split = 0.1f;
+            minimal_params.n_gqa = 8;
+            minimal_params.rms_norm_eps = 5e-6f;
+            minimal_params.model_alias = "unknown";
+            minimal_params.ubatch_size = 256;
+            minimal_params.ubatch_seq_len_max = 1;
+            
+            try {
+                load_success = context->loadModel(minimal_params);
+            } catch (const std::exception& e) {
+                LOGE("Exception during minimal model loading: %s", e.what());
+                load_success = false;
+            } catch (...) {
+                LOGE("Unknown exception during minimal model loading");
+                load_success = false;
+            }
             
-            load_success = context->loadModel(minimal_params);
             if (!load_success) {
                 LOGE("Model loading failed even with minimal parameters");
-                throw_java_exception(env, "java/lang/RuntimeException", "Failed to load model");
+                throw_java_exception(env, "java/lang/RuntimeException", "Failed to load model - possible model corruption or incompatibility");
                 return -1;
             }
         }
         
-        LOGI("Model loaded successfully: %s", model_path_str.c_str());
+        LOGI("Model loaded successfully!");
         
         // Store context
         jlong context_id = next_context_id++;
         contexts[context_id] = std::move(context);
         
-        LOGI("Initialized context %ld with model: %s", context_id, model_path_str.c_str());
+        LOGI("Initialized context %ld with model: %s", context_id, full_model_path.c_str());
         return context_id;
         
     } catch (const std::exception& e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llama-cpp-capacitor",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "A native Capacitor plugin that embeds llama.cpp directly into mobile apps, enabling offline AI inference with comprehensive support for text generation, multimodal processing, TTS, LoRA adapters, and more.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",