llama-cpp-capacitor 0.0.1

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

@@ -0,0 +1,677 @@
+package ai.annadata.plugin.capacitor;
+
+import android.util.Log;
+import com.getcapacitor.JSObject;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+
+// MARK: - Result Types
+class LlamaResult<T> {
+    private final T data;
+    private final LlamaError error;
+    private final boolean isSuccess;
+
+    private LlamaResult(T data, LlamaError error, boolean isSuccess) {
+        this.data = data;
+        this.error = error;
+        this.isSuccess = isSuccess;
+    }
+
+    public static <T> LlamaResult<T> success(T data) {
+        return new LlamaResult<>(data, null, true);
+    }
+
+    public static <T> LlamaResult<T> failure(LlamaError error) {
+        return new LlamaResult<>(null, error, false);
+    }
+
+    public boolean isSuccess() {
+        return isSuccess;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public LlamaError getError() {
+        return error;
+    }
+}
+
+class LlamaError extends Exception {
+    public LlamaError(String message) {
+        super(message);
+    }
+}
+
+// MARK: - Context Management
+class LlamaContext {
+    private final int id;
+    private LlamaModel model;
+    private boolean isMultimodalEnabled = false;
+    private boolean isVocoderEnabled = false;
+
+    public LlamaContext(int id) {
+        this.id = id;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public LlamaModel getModel() {
+        return model;
+    }
+
+    public void setModel(LlamaModel model) {
+        this.model = model;
+    }
+
+    public boolean isMultimodalEnabled() {
+        return isMultimodalEnabled;
+    }
+
+    public void setMultimodalEnabled(boolean multimodalEnabled) {
+        isMultimodalEnabled = multimodalEnabled;
+    }
+
+    public boolean isVocoderEnabled() {
+        return isVocoderEnabled;
+    }
+
+    public void setVocoderEnabled(boolean vocoderEnabled) {
+        isVocoderEnabled = vocoderEnabled;
+    }
+}
+
+class LlamaModel {
+    private final String path;
+    private final String desc;
+    private final int size;
+    private final int nEmbd;
+    private final int nParams;
+    private final ChatTemplates chatTemplates;
+    private final Map<String, Object> metadata;
+
+    public LlamaModel(String path, String desc, int size, int nEmbd, int nParams, ChatTemplates chatTemplates, Map<String, Object> metadata) {
+        this.path = path;
+        this.desc = desc;
+        this.size = size;
+        this.nEmbd = nEmbd;
+        this.nParams = nParams;
+        this.chatTemplates = chatTemplates;
+        this.metadata = metadata;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public int getNEmbd() {
+        return nEmbd;
+    }
+
+    public int getNParams() {
+        return nParams;
+    }
+
+    public ChatTemplates getChatTemplates() {
+        return chatTemplates;
+    }
+
+    public Map<String, Object> getMetadata() {
+        return metadata;
+    }
+}
+
+class ChatTemplates {
+    private final boolean llamaChat;
+    private final MinjaTemplates minja;
+
+    public ChatTemplates(boolean llamaChat, MinjaTemplates minja) {
+        this.llamaChat = llamaChat;
+        this.minja = minja;
+    }
+
+    public boolean isLlamaChat() {
+        return llamaChat;
+    }
+
+    public MinjaTemplates getMinja() {
+        return minja;
+    }
+}
+
+class MinjaTemplates {
+    private final boolean default_;
+    private final MinjaCaps defaultCaps;
+    private final boolean toolUse;
+    private final MinjaCaps toolUseCaps;
+
+    public MinjaTemplates(boolean default_, MinjaCaps defaultCaps, boolean toolUse, MinjaCaps toolUseCaps) {
+        this.default_ = default_;
+        this.defaultCaps = defaultCaps;
+        this.toolUse = toolUse;
+        this.toolUseCaps = toolUseCaps;
+    }
+
+    public boolean isDefault() {
+        return default_;
+    }
+
+    public MinjaCaps getDefaultCaps() {
+        return defaultCaps;
+    }
+
+    public boolean isToolUse() {
+        return toolUse;
+    }
+
+    public MinjaCaps getToolUseCaps() {
+        return toolUseCaps;
+    }
+}
+
+class MinjaCaps {
+    private final boolean tools;
+    private final boolean toolCalls;
+    private final boolean toolResponses;
+    private final boolean systemRole;
+    private final boolean parallelToolCalls;
+    private final boolean toolCallId;
+
+    public MinjaCaps(boolean tools, boolean toolCalls, boolean toolResponses, boolean systemRole, boolean parallelToolCalls, boolean toolCallId) {
+        this.tools = tools;
+        this.toolCalls = toolCalls;
+        this.toolResponses = toolResponses;
+        this.systemRole = systemRole;
+        this.parallelToolCalls = parallelToolCalls;
+        this.toolCallId = toolCallId;
+    }
+
+    public boolean isTools() {
+        return tools;
+    }
+
+    public boolean isToolCalls() {
+        return toolCalls;
+    }
+
+    public boolean isToolResponses() {
+        return toolResponses;
+    }
+
+    public boolean isSystemRole() {
+        return systemRole;
+    }
+
+    public boolean isParallelToolCalls() {
+        return parallelToolCalls;
+    }
+
+    public boolean isToolCallId() {
+        return toolCallId;
+    }
+}
+
+// MARK: - Main Implementation
+public class LlamaCpp {
+    private static final String TAG = "LlamaCpp";
+    private final Map<Integer, LlamaContext> contexts = new HashMap<>();
+    private int contextCounter = 0;
+    private int contextLimit = 10;
+    private boolean nativeLogEnabled = false;
+
+    // MARK: - Core initialization and management
+
+    public void toggleNativeLog(boolean enabled, LlamaCallback<Void> callback) {
+        nativeLogEnabled = enabled;
+        if (enabled) {
+            Log.i(TAG, "Native logging enabled");
+        } else {
+            Log.i(TAG, "Native logging disabled");
+        }
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    public void setContextLimit(int limit, LlamaCallback<Void> callback) {
+        contextLimit = limit;
+        Log.i(TAG, "Context limit set to " + limit);
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    public void modelInfo(String path, String[] skip, LlamaCallback<Map<String, Object>> callback) {
+        // This would typically load model info from the GGUF file
+        // For now, return a basic structure
+        Map<String, Object> modelInfo = new HashMap<>();
+        modelInfo.put("path", path);
+        modelInfo.put("desc", "Sample model");
+        modelInfo.put("size", 0);
+        modelInfo.put("nEmbd", 0);
+        modelInfo.put("nParams", 0);
+        callback.onResult(LlamaResult.success(modelInfo));
+    }
+
+    public void initContext(int contextId, JSObject params, LlamaCallback<Map<String, Object>> callback) {
+        // Check context limit
+        if (contexts.size() >= contextLimit) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context limit reached")));
+            return;
+        }
+
+        // Extract parameters
+        String modelPath = params.getString("model");
+        if (modelPath == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Invalid parameters")));
+            return;
+        }
+
+        // Create context
+        LlamaContext context = new LlamaContext(contextId);
+
+        // Create model info (this would typically load from GGUF file)
+        MinjaCaps defaultCaps = new MinjaCaps(true, true, true, true, true, true);
+        MinjaCaps toolUseCaps = new MinjaCaps(true, true, true, true, true, true);
+        MinjaTemplates minja = new MinjaTemplates(true, defaultCaps, true, toolUseCaps);
+        ChatTemplates chatTemplates = new ChatTemplates(true, minja);
+
+        LlamaModel model = new LlamaModel(
+            modelPath,
+            "Sample model",
+            0,
+            0,
+            0,
+            chatTemplates,
+            new HashMap<>()
+        );
+
+        context.setModel(model);
+        contexts.put(contextId, context);
+
+        // Return context info
+        Map<String, Object> contextInfo = new HashMap<>();
+        contextInfo.put("contextId", contextId);
+        contextInfo.put("gpu", false);
+        contextInfo.put("reasonNoGPU", "Not implemented");
+
+        Map<String, Object> modelInfo = new HashMap<>();
+        modelInfo.put("desc", model.getDesc());
+        modelInfo.put("size", model.getSize());
+        modelInfo.put("nEmbd", model.getNEmbd());
+        modelInfo.put("nParams", model.getNParams());
+
+        Map<String, Object> chatTemplatesInfo = new HashMap<>();
+        chatTemplatesInfo.put("llamaChat", model.getChatTemplates().isLlamaChat());
+
+        Map<String, Object> minjaInfo = new HashMap<>();
+        minjaInfo.put("default", model.getChatTemplates().getMinja().isDefault());
+
+        Map<String, Object> defaultCapsInfo = new HashMap<>();
+        defaultCapsInfo.put("tools", model.getChatTemplates().getMinja().getDefaultCaps().isTools());
+        defaultCapsInfo.put("toolCalls", model.getChatTemplates().getMinja().getDefaultCaps().isToolCalls());
+        defaultCapsInfo.put("toolResponses", model.getChatTemplates().getMinja().getDefaultCaps().isToolResponses());
+        defaultCapsInfo.put("systemRole", model.getChatTemplates().getMinja().getDefaultCaps().isSystemRole());
+        defaultCapsInfo.put("parallelToolCalls", model.getChatTemplates().getMinja().getDefaultCaps().isParallelToolCalls());
+        defaultCapsInfo.put("toolCallId", model.getChatTemplates().getMinja().getDefaultCaps().isToolCallId());
+
+        Map<String, Object> toolUseCapsInfo = new HashMap<>();
+        toolUseCapsInfo.put("tools", model.getChatTemplates().getMinja().getToolUseCaps().isTools());
+        toolUseCapsInfo.put("toolCalls", model.getChatTemplates().getMinja().getToolUseCaps().isToolCalls());
+        toolUseCapsInfo.put("toolResponses", model.getChatTemplates().getMinja().getToolUseCaps().isToolResponses());
+        toolUseCapsInfo.put("systemRole", model.getChatTemplates().getMinja().getToolUseCaps().isSystemRole());
+        toolUseCapsInfo.put("parallelToolCalls", model.getChatTemplates().getMinja().getToolUseCaps().isParallelToolCalls());
+        toolUseCapsInfo.put("toolCallId", model.getChatTemplates().getMinja().getToolUseCaps().isToolCallId());
+
+        minjaInfo.put("defaultCaps", defaultCapsInfo);
+        minjaInfo.put("toolUse", model.getChatTemplates().getMinja().isToolUse());
+        minjaInfo.put("toolUseCaps", toolUseCapsInfo);
+
+        chatTemplatesInfo.put("minja", minjaInfo);
+        modelInfo.put("chatTemplates", chatTemplatesInfo);
+        modelInfo.put("metadata", model.getMetadata());
+        modelInfo.put("isChatTemplateSupported", true);
+
+        contextInfo.put("model", modelInfo);
+
+        callback.onResult(LlamaResult.success(contextInfo));
+    }
+
+    public void releaseContext(int contextId, LlamaCallback<Void> callback) {
+        if (contexts.remove(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    public void releaseAllContexts(LlamaCallback<Void> callback) {
+        contexts.clear();
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    // MARK: - Chat and completion
+
+    public void getFormattedChat(int contextId, String messages, String chatTemplate, JSObject params, LlamaCallback<Map<String, Object>> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically format the chat using the model's chat templates
+        // For now, return a basic formatted chat
+        Map<String, Object> formattedChat = new HashMap<>();
+        formattedChat.put("type", "llama-chat");
+        formattedChat.put("prompt", messages);
+        formattedChat.put("has_media", false);
+        formattedChat.put("media_paths", new String[0]);
+
+        callback.onResult(LlamaResult.success(formattedChat));
+    }
+
+    public void completion(int contextId, JSObject params, LlamaCallback<Map<String, Object>> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically perform the completion using llama.cpp
+        // For now, return a basic completion result
+        Map<String, Object> completionResult = new HashMap<>();
+        completionResult.put("text", "Sample completion text");
+        completionResult.put("reasoning_content", "");
+        completionResult.put("tool_calls", new Object[0]);
+        completionResult.put("content", "Sample completion text");
+        completionResult.put("chat_format", 0);
+        completionResult.put("tokens_predicted", 0);
+        completionResult.put("tokens_evaluated", 0);
+        completionResult.put("truncated", false);
+        completionResult.put("stopped_eos", false);
+        completionResult.put("stopped_word", "");
+        completionResult.put("stopped_limit", 0);
+        completionResult.put("stopping_word", "");
+        completionResult.put("context_full", false);
+        completionResult.put("interrupted", false);
+        completionResult.put("tokens_cached", 0);
+
+        Map<String, Object> timings = new HashMap<>();
+        timings.put("prompt_n", 0);
+        timings.put("prompt_ms", 0);
+        timings.put("prompt_per_token_ms", 0);
+        timings.put("prompt_per_second", 0);
+        timings.put("predicted_n", 0);
+        timings.put("predicted_ms", 0);
+        timings.put("predicted_per_token_ms", 0);
+        timings.put("predicted_per_second", 0);
+
+        completionResult.put("timings", timings);
+
+        callback.onResult(LlamaResult.success(completionResult));
+    }
+
+    public void stopCompletion(int contextId, LlamaCallback<Void> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically stop any ongoing completion
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    // MARK: - Session management
+
+    public void loadSession(int contextId, String filepath, LlamaCallback<Map<String, Object>> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically load session from file
+        Map<String, Object> sessionResult = new HashMap<>();
+        sessionResult.put("tokens_loaded", 0);
+        sessionResult.put("prompt", "");
+
+        callback.onResult(LlamaResult.success(sessionResult));
+    }
+
+    public void saveSession(int contextId, String filepath, int size, LlamaCallback<Integer> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically save session to file
+        callback.onResult(LlamaResult.success(0));
+    }
+
+    // MARK: - Tokenization
+
+    public void tokenize(int contextId, String text, String[] imagePaths, LlamaCallback<Map<String, Object>> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically tokenize the text using the model's tokenizer
+        Map<String, Object> tokenizeResult = new HashMap<>();
+        tokenizeResult.put("tokens", new Integer[0]);
+        tokenizeResult.put("has_images", false);
+        tokenizeResult.put("bitmap_hashes", new Integer[0]);
+        tokenizeResult.put("chunk_pos", new Integer[0]);
+        tokenizeResult.put("chunk_pos_images", new Integer[0]);
+
+        callback.onResult(LlamaResult.success(tokenizeResult));
+    }
+
+    public void detokenize(int contextId, Integer[] tokens, LlamaCallback<String> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically detokenize using the model's tokenizer
+        callback.onResult(LlamaResult.success(""));
+    }
+
+    // MARK: - Embeddings and reranking
+
+    public void embedding(int contextId, String text, JSObject params, LlamaCallback<Map<String, Object>> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically generate embeddings
+        Map<String, Object> embeddingResult = new HashMap<>();
+        embeddingResult.put("embedding", new Double[0]);
+
+        callback.onResult(LlamaResult.success(embeddingResult));
+    }
+
+    public void rerank(int contextId, String query, String[] documents, JSObject params, LlamaCallback<Map<String, Object>[]> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically perform reranking
+        Map<String, Object>[] rerankResults = new Map[0];
+        callback.onResult(LlamaResult.success(rerankResults));
+    }
+
+    // MARK: - Benchmarking
+
+    public void bench(int contextId, int pp, int tg, int pl, int nr, LlamaCallback<String> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically run benchmarks
+        String benchResult = "[]";
+        callback.onResult(LlamaResult.success(benchResult));
+    }
+
+    // MARK: - LoRA adapters
+
+    public void applyLoraAdapters(int contextId, JSObject[] loraAdapters, LlamaCallback<Void> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically apply LoRA adapters
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    public void removeLoraAdapters(int contextId, LlamaCallback<Void> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically remove LoRA adapters
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    public void getLoadedLoraAdapters(int contextId, LlamaCallback<Map<String, Object>[]> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        // This would typically return loaded LoRA adapters
+        Map<String, Object>[] adapters = new Map[0];
+        callback.onResult(LlamaResult.success(adapters));
+    }
+
+    // MARK: - Multimodal methods
+
+    public void initMultimodal(int contextId, String path, boolean useGpu, LlamaCallback<Boolean> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        context.setMultimodalEnabled(true);
+        callback.onResult(LlamaResult.success(true));
+    }
+
+    public void isMultimodalEnabled(int contextId, LlamaCallback<Boolean> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        callback.onResult(LlamaResult.success(context.isMultimodalEnabled()));
+    }
+
+    public void getMultimodalSupport(int contextId, LlamaCallback<Map<String, Object>> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        Map<String, Object> support = new HashMap<>();
+        support.put("vision", true);
+        support.put("audio", true);
+
+        callback.onResult(LlamaResult.success(support));
+    }
+
+    public void releaseMultimodal(int contextId, LlamaCallback<Void> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        context.setMultimodalEnabled(false);
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    // MARK: - TTS methods
+
+    public void initVocoder(int contextId, String path, Integer nBatch, LlamaCallback<Boolean> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        context.setVocoderEnabled(true);
+        callback.onResult(LlamaResult.success(true));
+    }
+
+    public void isVocoderEnabled(int contextId, LlamaCallback<Boolean> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        callback.onResult(LlamaResult.success(context.isVocoderEnabled()));
+    }
+
+    public void getFormattedAudioCompletion(int contextId, String speakerJsonStr, String textToSpeak, LlamaCallback<Map<String, Object>> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        Map<String, Object> audioCompletion = new HashMap<>();
+        audioCompletion.put("prompt", "");
+        audioCompletion.put("grammar", null);
+
+        callback.onResult(LlamaResult.success(audioCompletion));
+    }
+
+    public void getAudioCompletionGuideTokens(int contextId, String textToSpeak, LlamaCallback<Integer[]> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        Integer[] tokens = new Integer[0];
+        callback.onResult(LlamaResult.success(tokens));
+    }
+
+    public void decodeAudioTokens(int contextId, Integer[] tokens, LlamaCallback<Integer[]> callback) {
+        if (contexts.get(contextId) == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        Integer[] decodedTokens = new Integer[0];
+        callback.onResult(LlamaResult.success(decodedTokens));
+    }
+
+    public void releaseVocoder(int contextId, LlamaCallback<Void> callback) {
+        LlamaContext context = contexts.get(contextId);
+        if (context == null) {
+            callback.onResult(LlamaResult.failure(new LlamaError("Context not found")));
+            return;
+        }
+
+        context.setVocoderEnabled(false);
+        callback.onResult(LlamaResult.success(null));
+    }
+
+    // MARK: - Callback Interface
+    public interface LlamaCallback<T> {
+        void onResult(LlamaResult<T> result);
+    }
+}