llama-cpp-capacitor 0.0.10 → 0.0.13

package/android/src/main/jni.cpp

@@ -3,6 +3,9 @@
 #include <android/log.h>
 #include <cstring>
 #include <memory>
+#include <fstream> // Added for file existence and size checks
+#include <signal.h> // Added for signal handling
+#include <sys/signal.h> // Added for sigaction
 
 // Add missing symbol
 namespace rnllama {
@@ -139,13 +142,92 @@ 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;
+        }
+        
+        // Additional model validation
+        LOGI("Performing additional model validation...");
+        std::ifstream validation_file(full_model_path, std::ios::binary);
+        if (validation_file.good()) {
+            // Read first 8 bytes to check GGUF version
+            char header[8];
+            if (validation_file.read(header, 8)) {
+                uint32_t version = *reinterpret_cast<uint32_t*>(header + 4);
+                LOGI("GGUF version: %u", version);
+                
+                // Check if version is reasonable (should be > 0 and < 1000)
+                if (version == 0 || version > 1000) {
+                    LOGE("Suspicious GGUF version: %u", version);
+                    LOGI("This might indicate a corrupted or incompatible model file");
+                }
+            }
+            validation_file.close();
+        }
+
         // 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 +281,135 @@ 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 and signal protection
+        bool load_success = false;
+        
+        // Set up signal handler to catch segmentation faults
+        struct sigaction old_action;
+        struct sigaction new_action;
+        new_action.sa_handler = [](int sig) {
+            LOGE("Segmentation fault caught during model loading");
+            // Restore default handler and re-raise signal
+            signal(sig, SIG_DFL);
+            raise(sig);
+        };
+        new_action.sa_flags = SA_RESETHAND;
+        sigemptyset(&new_action.sa_mask);
+        
+        if (sigaction(SIGSEGV, &new_action, &old_action) == 0) {
+            LOGI("Signal handler installed for segmentation fault protection");
+        }
+        
+        try {
+            LOGI("Attempting to load model with standard parameters...");
+            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;
+        }
+        
+        // Restore original signal handler
+        sigaction(SIGSEGV, &old_action, nullptr);
+        
         if (!load_success) {
-            LOGE("Model loading failed for: %s", model_path_str.c_str());
+            LOGE("context->loadModel() returned false - model loading failed");
+            
+            // Try with ultra-minimal parameters as fallback
+            LOGI("Trying with ultra-minimal parameters...");
+            common_params ultra_minimal_params;
+            ultra_minimal_params.model.path = full_model_path;
+            ultra_minimal_params.n_ctx = 256;  // Very small context
+            ultra_minimal_params.n_batch = 128; // Very small batch
+            ultra_minimal_params.n_gpu_layers = 0;
+            ultra_minimal_params.use_mmap = false; // Disable mmap to avoid memory issues
+            ultra_minimal_params.use_mlock = false;
+            ultra_minimal_params.numa = LM_GGML_NUMA_STRATEGY_DISABLED;
+            ultra_minimal_params.ctx_shift = false;
+            ultra_minimal_params.chat_template = "";
+            ultra_minimal_params.embedding = false;
+            ultra_minimal_params.cont_batching = false;
+            ultra_minimal_params.parallel = false;
+            ultra_minimal_params.grammar = "";
+            ultra_minimal_params.grammar_penalty.clear();
+            ultra_minimal_params.antiprompt.clear();
+            ultra_minimal_params.lora_adapter.clear();
+            ultra_minimal_params.lora_base = "";
+            ultra_minimal_params.mul_mat_q = false; // Disable quantized matrix multiplication
+            ultra_minimal_params.f16_kv = false; // Disable f16 key-value cache
+            ultra_minimal_params.logits_all = false;
+            ultra_minimal_params.vocab_only = false;
+            ultra_minimal_params.rope_scaling_type = LLAMA_ROPE_SCALING_TYPE_UNSPECIFIED;
+            ultra_minimal_params.rope_scaling_factor = 0.0f;
+            ultra_minimal_params.rope_scaling_orig_ctx_len = 0;
+            ultra_minimal_params.yarn_ext_factor = -1.0f;
+            ultra_minimal_params.yarn_attn_factor = 1.0f;
+            ultra_minimal_params.yarn_beta_fast = 32.0f;
+            ultra_minimal_params.yarn_beta_slow = 1.0f;
+            ultra_minimal_params.yarn_orig_ctx = 0;
+            ultra_minimal_params.offload_kqv = false; // Disable offloading
+            ultra_minimal_params.flash_attn = false;
+            ultra_minimal_params.flash_attn_kernel = false;
+            ultra_minimal_params.flash_attn_causal = true;
+            ultra_minimal_params.mmproj = "";
+            ultra_minimal_params.image = "";
+            ultra_minimal_params.export = "";
+            ultra_minimal_params.export_path = "";
+            ultra_minimal_params.seed = -1;
+            ultra_minimal_params.n_keep = 0;
+            ultra_minimal_params.n_discard = -1;
+            ultra_minimal_params.n_draft = 0;
+            ultra_minimal_params.n_chunks = -1;
+            ultra_minimal_params.n_parallel = 1;
+            ultra_minimal_params.n_sequences = 1;
+            ultra_minimal_params.p_accept = 0.5f;
+            ultra_minimal_params.p_split = 0.1f;
+            ultra_minimal_params.n_gqa = 8;
+            ultra_minimal_params.rms_norm_eps = 5e-6f;
+            ultra_minimal_params.model_alias = "unknown";
+            ultra_minimal_params.ubatch_size = 128;
+            ultra_minimal_params.ubatch_seq_len_max = 1;
+            
+            // Set up signal handler again for ultra-minimal attempt
+            if (sigaction(SIGSEGV, &new_action, &old_action) == 0) {
+                LOGI("Signal handler reinstalled for ultra-minimal attempt");
+            }
+            
+            try {
+                load_success = context->loadModel(ultra_minimal_params);
+            } catch (const std::exception& e) {
+                LOGE("Exception during ultra-minimal model loading: %s", e.what());
+                load_success = false;
+            } catch (...) {
+                LOGE("Unknown exception during ultra-minimal model loading");
+                load_success = false;
+            }
             
-            // Try with minimal parameters as fallback
-            LOGI("Trying with minimal parameters...");
-            common_params minimal_params;
-            minimal_params.model.path = model_path_str;
-            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;
+            // Restore original signal handler
+            sigaction(SIGSEGV, &old_action, nullptr);
             
-            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");
+                LOGE("Model loading failed even with ultra-minimal parameters");
+                throw_java_exception(env, "java/lang/RuntimeException", 
+                    "Failed to load model - model appears to be corrupted or incompatible with this llama.cpp version. "
+                    "Try downloading a fresh copy of the model file.");
                 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.13",
   "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",