llama-cpp-capacitor 0.0.1

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

@@ -0,0 +1,482 @@
+package ai.annadata.plugin.capacitor;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "LlamaCpp")
+public class LlamaCppPlugin extends Plugin {
+
+    private LlamaCpp implementation = new LlamaCpp();
+
+    // MARK: - Core initialization and management
+
+    @PluginMethod
+    public void toggleNativeLog(PluginCall call) {
+        boolean enabled = call.getBoolean("enabled", false);
+        implementation.toggleNativeLog(enabled, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void setContextLimit(PluginCall call) {
+        int limit = call.getInt("limit", 10);
+        implementation.setContextLimit(limit, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void modelInfo(PluginCall call) {
+        String path = call.getString("path", "");
+        String[] skip = call.getArray("skip", String.class);
+        if (skip == null) skip = new String[0];
+
+        implementation.modelInfo(path, skip, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void initContext(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        JSObject params = call.getObject("params", new JSObject());
+
+        implementation.initContext(contextId, params, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void releaseContext(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.releaseContext(contextId, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void releaseAllContexts(PluginCall call) {
+        implementation.releaseAllContexts(result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - Chat and completion
+
+    @PluginMethod
+    public void getFormattedChat(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String messages = call.getString("messages", "");
+        String chatTemplate = call.getString("chatTemplate");
+        JSObject params = call.getObject("params");
+
+        implementation.getFormattedChat(contextId, messages, chatTemplate, params, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void completion(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        JSObject params = call.getObject("params", new JSObject());
+
+        implementation.completion(contextId, params, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void stopCompletion(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.stopCompletion(contextId, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - Session management
+
+    @PluginMethod
+    public void loadSession(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String filepath = call.getString("filepath", "");
+
+        implementation.loadSession(contextId, filepath, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void saveSession(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String filepath = call.getString("filepath", "");
+        int size = call.getInt("size", -1);
+
+        implementation.saveSession(contextId, filepath, size, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("tokensSaved", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - Tokenization
+
+    @PluginMethod
+    public void tokenize(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String text = call.getString("text", "");
+        String[] imagePaths = call.getArray("imagePaths", String.class);
+        if (imagePaths == null) imagePaths = new String[0];
+
+        implementation.tokenize(contextId, text, imagePaths, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void detokenize(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        Integer[] tokens = call.getArray("tokens", Integer.class);
+        if (tokens == null) tokens = new Integer[0];
+
+        implementation.detokenize(contextId, tokens, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("text", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - Embeddings and reranking
+
+    @PluginMethod
+    public void embedding(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String text = call.getString("text", "");
+        JSObject params = call.getObject("params", new JSObject());
+
+        implementation.embedding(contextId, text, params, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void rerank(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String query = call.getString("query", "");
+        String[] documents = call.getArray("documents", String.class);
+        if (documents == null) documents = new String[0];
+        JSObject params = call.getObject("params");
+
+        implementation.rerank(contextId, query, documents, params, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("results", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - Benchmarking
+
+    @PluginMethod
+    public void bench(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        int pp = call.getInt("pp", 0);
+        int tg = call.getInt("tg", 0);
+        int pl = call.getInt("pl", 0);
+        int nr = call.getInt("nr", 0);
+
+        implementation.bench(contextId, pp, tg, pl, nr, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("result", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - LoRA adapters
+
+    @PluginMethod
+    public void applyLoraAdapters(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        JSObject[] loraAdapters = call.getArray("loraAdapters", JSObject.class);
+        if (loraAdapters == null) loraAdapters = new JSObject[0];
+
+        implementation.applyLoraAdapters(contextId, loraAdapters, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void removeLoraAdapters(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.removeLoraAdapters(contextId, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void getLoadedLoraAdapters(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.getLoadedLoraAdapters(contextId, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("adapters", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - Multimodal methods
+
+    @PluginMethod
+    public void initMultimodal(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        JSObject params = call.getObject("params", new JSObject());
+        String path = params.getString("path", "");
+        boolean useGpu = params.getBoolean("use_gpu", true);
+
+        implementation.initMultimodal(contextId, path, useGpu, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("success", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void isMultimodalEnabled(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.isMultimodalEnabled(contextId, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("enabled", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void getMultimodalSupport(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.getMultimodalSupport(contextId, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void releaseMultimodal(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.releaseMultimodal(contextId, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - TTS methods
+
+    @PluginMethod
+    public void initVocoder(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        JSObject params = call.getObject("params", new JSObject());
+        String path = params.getString("path", "");
+        Integer nBatch = params.getInteger("n_batch");
+
+        implementation.initVocoder(contextId, path, nBatch, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("success", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void isVocoderEnabled(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.isVocoderEnabled(contextId, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("enabled", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void getFormattedAudioCompletion(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String speakerJsonStr = call.getString("speakerJsonStr", "");
+        String textToSpeak = call.getString("textToSpeak", "");
+
+        implementation.getFormattedAudioCompletion(contextId, speakerJsonStr, textToSpeak, result -> {
+            if (result.isSuccess()) {
+                call.resolve(result.getData());
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void getAudioCompletionGuideTokens(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        String textToSpeak = call.getString("textToSpeak", "");
+
+        implementation.getAudioCompletionGuideTokens(contextId, textToSpeak, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("tokens", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void decodeAudioTokens(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+        Integer[] tokens = call.getArray("tokens", Integer.class);
+        if (tokens == null) tokens = new Integer[0];
+
+        implementation.decodeAudioTokens(contextId, tokens, result -> {
+            if (result.isSuccess()) {
+                JSObject ret = new JSObject();
+                ret.put("decodedTokens", result.getData());
+                call.resolve(ret);
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void releaseVocoder(PluginCall call) {
+        int contextId = call.getInt("contextId", 0);
+
+        implementation.releaseVocoder(contextId, result -> {
+            if (result.isSuccess()) {
+                call.resolve();
+            } else {
+                call.reject(result.getError().getMessage());
+            }
+        });
+    }
+
+    // MARK: - Events
+
+    @PluginMethod
+    public void addListener(PluginCall call) {
+        String eventName = call.getString("eventName", "");
+        // Note: In Capacitor, event listeners are typically handled differently
+        // This is a placeholder for the event system
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void removeAllListeners(PluginCall call) {
+        String eventName = call.getString("eventName", "");
+        // Note: In Capacitor, event listeners are typically handled differently
+        // This is a placeholder for the event system
+        call.resolve();
+    }
+}

package/android/src/main/jni-utils.h

@@ -0,0 +1,139 @@
+#ifndef JNI_UTILS_H
+#define JNI_UTILS_H
+
+#include <jni.h>
+#include <string>
+#include <vector>
+#include "rn-llama.h"
+
+namespace jni_utils {
+
+// Convert Java string to C++ string
+std::string jstring_to_string(JNIEnv* env, jstring jstr);
+
+// Convert C++ string to Java string
+jstring string_to_jstring(JNIEnv* env, const std::string& str);
+
+// Convert Java string array to C++ string vector
+std::vector<std::string> jstring_array_to_string_vector(JNIEnv* env, jobjectArray jarray);
+
+// Convert C++ string vector to Java string array
+jobjectArray string_vector_to_jstring_array(JNIEnv* env, const std::vector<std::string>& vec);
+
+// Convert Java boolean to C++ bool
+bool jboolean_to_bool(jboolean jbool);
+
+// Convert C++ bool to Java boolean
+jboolean bool_to_jboolean(bool b);
+
+// Convert Java int to C++ int
+int jint_to_int(jint jint_val);
+
+// Convert C++ int to Java int
+jint int_to_jint(int val);
+
+// Convert Java float to C++ float
+float jfloat_to_float(jfloat jfloat_val);
+
+// Convert C++ float to Java float
+jfloat float_to_jfloat(float val);
+
+// Convert Java long to C++ long
+long jlong_to_long(jlong jlong_val);
+
+// Convert C++ long to Java long
+jlong long_to_jlong(long val);
+
+// Convert Java double to C++ double
+double jdouble_to_double(jdouble jdouble_val);
+
+// Convert C++ double to Java double
+jdouble double_to_jdouble(double val);
+
+// Throw Java exception
+void throw_java_exception(JNIEnv* env, const char* class_name, const char* message);
+
+// Check if exception occurred
+bool check_exception(JNIEnv* env);
+
+// Get field ID safely
+jfieldID get_field_id(JNIEnv* env, jclass clazz, const char* name, const char* sig);
+
+// Get method ID safely
+jmethodID get_method_id(JNIEnv* env, jclass clazz, const char* name, const char* sig);
+
+// Find class safely
+jclass find_class(JNIEnv* env, const char* name);
+
+// Create object safely
+jobject create_object(JNIEnv* env, jclass clazz, jmethodID constructor, ...);
+
+// Call method safely
+jobject call_method(JNIEnv* env, jobject obj, jmethodID method, ...);
+
+// Call static method safely
+jobject call_static_method(JNIEnv* env, jclass clazz, jmethodID method, ...);
+
+// Set field safely
+void set_field(JNIEnv* env, jobject obj, jfieldID field, ...);
+
+// Get field safely
+jobject get_field(JNIEnv* env, jobject obj, jfieldID field);
+
+// Set static field safely
+void set_static_field(JNIEnv* env, jclass clazz, jfieldID field, ...);
+
+// Get static field safely
+jobject get_static_field(JNIEnv* env, jclass clazz, jfieldID field);
+
+// Convert llama_rn_context to jobject
+jobject llama_context_to_jobject(JNIEnv* env, const llama_rn_context* context);
+
+// Convert jobject to llama_rn_context
+llama_rn_context* jobject_to_llama_context(JNIEnv* env, jobject obj);
+
+// Convert completion result to jobject
+jobject completion_result_to_jobject(JNIEnv* env, const completion_token_output& result);
+
+// Convert jobject to completion parameters
+completion_params jobject_to_completion_params(JNIEnv* env, jobject obj);
+
+// Convert chat parameters to jobject
+jobject chat_params_to_jobject(JNIEnv* env, const common_chat_params& params);
+
+// Convert jobject to chat parameters
+common_chat_params jobject_to_chat_params(JNIEnv* env, jobject obj);
+
+// Convert tokenize result to jobject
+jobject tokenize_result_to_jobject(JNIEnv* env, const llama_rn_tokenize_result& result);
+
+// Convert embedding result to jobject
+jobject embedding_result_to_jobject(JNIEnv* env, const std::vector<float>& embedding);
+
+// Convert rerank result to jobject
+jobject rerank_result_to_jobject(JNIEnv* env, const std::vector<std::pair<size_t, float>>& results);
+
+// Convert benchmark result to jobject
+jobject benchmark_result_to_jobject(JNIEnv* env, const std::vector<float>& timings);
+
+// Convert LoRA adapter info to jobject
+jobject lora_adapter_info_to_jobject(JNIEnv* env, const common_adapter_lora_info& info);
+
+// Convert jobject to LoRA adapter info
+common_adapter_lora_info jobject_to_lora_adapter_info(JNIEnv* env, jobject obj);
+
+// Convert multimodal support info to jobject
+jobject multimodal_support_to_jobject(JNIEnv* env, bool vision, bool audio);
+
+// Convert TTS result to jobject
+jobject tts_result_to_jobject(JNIEnv* env, const std::vector<float>& audio_data, int sample_rate);
+
+// Convert session data to jobject
+jobject session_data_to_jobject(JNIEnv* env, const std::string& data);
+
+// Convert jobject to session data
+std::string jobject_to_session_data(JNIEnv* env, jobject obj);
+
+} // namespace jni_utils
+
+#endif // JNI_UTILS_H