cactus-react-native 0.0.1 → 0.1.1

package/android/src/main/java/com/cactus/LlamaContext.java

@@ -220,10 +220,14 @@ public class LlamaContext {
   }
 
   public WritableMap completion(ReadableMap params) {
+    Log.d(NAME, "🔵 ANDROID: completion() called");
     if (!params.hasKey("prompt")) {
       throw new IllegalArgumentException("Missing required parameter: prompt");
     }
 
+    Log.d(NAME, "📝 ANDROID: prompt length = " + params.getString("prompt").length());
+    Log.d(NAME, "🧮 ANDROID: context ptr = " + this.context);
+
     double[][] logit_bias = new double[0][0];
     if (params.hasKey("logit_bias")) {
       ReadableArray logit_bias_array = params.getArray("logit_bias");
@@ -237,6 +241,7 @@ public class LlamaContext {
       }
     }
 
+    Log.d(NAME, "🚀 ANDROID: About to call doCompletion native method...");
     WritableMap result = doCompletion(
       this.context,
       // String prompt,
@@ -313,9 +318,12 @@ public class LlamaContext {
         params.hasKey("emit_partial_completion") ? params.getBoolean("emit_partial_completion") : false
       )
     );
+    Log.d(NAME, "✅ ANDROID: doCompletion returned successfully");
     if (result.hasKey("error")) {
+      Log.e(NAME, "❌ ANDROID: doCompletion returned error: " + result.getString("error"));
       throw new IllegalStateException(result.getString("error"));
     }
+    Log.d(NAME, "📤 ANDROID: completion() returning result");
     return result;
   }
 
@@ -381,6 +389,141 @@ public class LlamaContext {
     freeContext(context);
   }
 
+  // Multimodal methods
+  public boolean initMultimodal(String mmprojPath, boolean useGpu) {
+    return initMultimodal(this.context, mmprojPath, useGpu);
+  }
+
+  public boolean isMultimodalEnabled() {
+    return isMultimodalEnabled(this.context);
+  }
+
+  public boolean isMultimodalSupportVision() {
+    return isMultimodalSupportVision(this.context);
+  }
+
+  public boolean isMultimodalSupportAudio() {
+    return isMultimodalSupportAudio(this.context);
+  }
+
+  public void releaseMultimodal() {
+    releaseMultimodal(this.context);
+  }
+
+  public WritableMap multimodalCompletion(String prompt, ReadableArray mediaPaths, ReadableMap params) {
+    if (!params.hasKey("prompt")) {
+      params = Arguments.createMap();
+      ((WritableMap) params).putString("prompt", prompt);
+    }
+
+    String[] mediaPathsArray = new String[mediaPaths.size()];
+    for (int i = 0; i < mediaPaths.size(); i++) {
+      mediaPathsArray[i] = mediaPaths.getString(i);
+    }
+
+    double[][] logit_bias = new double[0][0];
+    if (params.hasKey("logit_bias")) {
+      ReadableArray logit_bias_array = params.getArray("logit_bias");
+      logit_bias = new double[logit_bias_array.size()][];
+      for (int i = 0; i < logit_bias_array.size(); i++) {
+        ReadableArray logit_bias_row = logit_bias_array.getArray(i);
+        logit_bias[i] = new double[logit_bias_row.size()];
+        for (int j = 0; j < logit_bias_row.size(); j++) {
+          logit_bias[i][j] = logit_bias_row.getDouble(j);
+        }
+      }
+    }
+
+    WritableMap result = doMultimodalCompletion(
+      this.context,
+      prompt,
+      mediaPathsArray,
+      params.hasKey("chat_format") ? params.getInt("chat_format") : 0,
+      params.hasKey("grammar") ? params.getString("grammar") : "",
+      params.hasKey("json_schema") ? params.getString("json_schema") : "",
+      params.hasKey("grammar_lazy") ? params.getBoolean("grammar_lazy") : false,
+      params.hasKey("grammar_triggers") ? params.getArray("grammar_triggers") : null,
+      params.hasKey("preserved_tokens") ? params.getArray("preserved_tokens") : null,
+      params.hasKey("temperature") ? (float) params.getDouble("temperature") : 0.7f,
+      params.hasKey("n_threads") ? params.getInt("n_threads") : 0,
+      params.hasKey("n_predict") ? params.getInt("n_predict") : -1,
+      params.hasKey("n_probs") ? params.getInt("n_probs") : 0,
+      params.hasKey("penalty_last_n") ? params.getInt("penalty_last_n") : 64,
+      params.hasKey("penalty_repeat") ? (float) params.getDouble("penalty_repeat") : 1.00f,
+      params.hasKey("penalty_freq") ? (float) params.getDouble("penalty_freq") : 0.00f,
+      params.hasKey("penalty_present") ? (float) params.getDouble("penalty_present") : 0.00f,
+      params.hasKey("mirostat") ? (float) params.getDouble("mirostat") : 0.00f,
+      params.hasKey("mirostat_tau") ? (float) params.getDouble("mirostat_tau") : 5.00f,
+      params.hasKey("mirostat_eta") ? (float) params.getDouble("mirostat_eta") : 0.10f,
+      params.hasKey("top_k") ? params.getInt("top_k") : 40,
+      params.hasKey("top_p") ? (float) params.getDouble("top_p") : 0.95f,
+      params.hasKey("min_p") ? (float) params.getDouble("min_p") : 0.05f,
+      params.hasKey("xtc_threshold") ? (float) params.getDouble("xtc_threshold") : 0.00f,
+      params.hasKey("xtc_probability") ? (float) params.getDouble("xtc_probability") : 0.00f,
+      params.hasKey("typical_p") ? (float) params.getDouble("typical_p") : 1.00f,
+      params.hasKey("seed") ? params.getInt("seed") : -1,
+      params.hasKey("stop") ? params.getArray("stop").toArrayList().toArray(new String[0]) : new String[0],
+      params.hasKey("ignore_eos") ? params.getBoolean("ignore_eos") : false,
+      logit_bias,
+      params.hasKey("dry_multiplier") ? (float) params.getDouble("dry_multiplier") : 0.00f,
+      params.hasKey("dry_base") ? (float) params.getDouble("dry_base") : 1.75f,
+      params.hasKey("dry_allowed_length") ? params.getInt("dry_allowed_length") : 2,
+      params.hasKey("dry_penalty_last_n") ? params.getInt("dry_penalty_last_n") : -1,
+      params.hasKey("top_n_sigma") ? (float) params.getDouble("top_n_sigma") : -1.0f,
+      params.hasKey("dry_sequence_breakers") ? params.getArray("dry_sequence_breakers").toArrayList().toArray(new String[0]) : new String[]{"\n", ":", "\"", "*"},
+      new PartialCompletionCallback(
+        this,
+        params.hasKey("emit_partial_completion") ? params.getBoolean("emit_partial_completion") : false
+      )
+    );
+    if (result.hasKey("error")) {
+      throw new IllegalStateException(result.getString("error"));
+    }
+    return result;
+  }
+
+  public WritableMap tokenize(String text, ReadableArray mediaPaths) {
+    String[] mediaPathsArray = new String[mediaPaths.size()];
+    for (int i = 0; i < mediaPaths.size(); i++) {
+      mediaPathsArray[i] = mediaPaths.getString(i);
+    }
+    WritableMap result = tokenize(this.context, text, mediaPathsArray);
+    return result;
+  }
+
+  // TTS/Vocoder methods
+  public boolean initVocoder(String vocoderModelPath) {
+    return initVocoder(this.context, vocoderModelPath);
+  }
+
+  public boolean isVocoderEnabled() {
+    return isVocoderEnabled(this.context);
+  }
+
+  public int getTTSType() {
+    return getTTSType(this.context);
+  }
+
+  public String getFormattedAudioCompletion(String speakerJsonStr, String textToSpeak) {
+    return getFormattedAudioCompletion(this.context, speakerJsonStr, textToSpeak);
+  }
+
+  public WritableArray getAudioCompletionGuideTokens(String textToSpeak) {
+    return getAudioCompletionGuideTokens(this.context, textToSpeak);
+  }
+
+  public WritableArray decodeAudioTokens(ReadableArray tokens) {
+    int[] toks = new int[tokens.size()];
+    for (int i = 0; i < tokens.size(); i++) {
+      toks[i] = (int) tokens.getDouble(i);
+    }
+    return decodeAudioTokens(this.context, toks);
+  }
+
+  public void releaseVocoder() {
+    releaseVocoder(this.context);
+  }
+
   static {
     Log.d(NAME, "Primary ABI: " + Build.SUPPORTED_ABIS[0]);
 
@@ -576,4 +719,60 @@ public class LlamaContext {
   protected static native void freeContext(long contextPtr);
   protected static native void setupLog(NativeLogCallback logCallback);
   protected static native void unsetLog();
+
+  // Multimodal native methods
+  protected static native boolean initMultimodal(long contextPtr, String mmprojPath, boolean useGpu);
+  protected static native boolean isMultimodalEnabled(long contextPtr);
+  protected static native boolean isMultimodalSupportVision(long contextPtr);
+  protected static native boolean isMultimodalSupportAudio(long contextPtr);
+  protected static native void releaseMultimodal(long contextPtr);
+  protected static native WritableMap doMultimodalCompletion(
+    long contextPtr,
+    String prompt,
+    String[] mediaPaths,
+    int chat_format,
+    String grammar,
+    String json_schema,
+    boolean grammar_lazy,
+    ReadableArray grammar_triggers,
+    ReadableArray preserved_tokens,
+    float temperature,
+    int n_threads,
+    int n_predict,
+    int n_probs,
+    int penalty_last_n,
+    float penalty_repeat,
+    float penalty_freq,
+    float penalty_present,
+    float mirostat,
+    float mirostat_tau,
+    float mirostat_eta,
+    int top_k,
+    float top_p,
+    float min_p,
+    float xtc_threshold,
+    float xtc_probability,
+    float typical_p,
+    int seed,
+    String[] stop,
+    boolean ignore_eos,
+    double[][] logit_bias,
+    float dry_multiplier,
+    float dry_base,
+    int dry_allowed_length,
+    int dry_penalty_last_n,
+    float top_n_sigma,
+    String[] dry_sequence_breakers,
+    PartialCompletionCallback partial_completion_callback
+  );
+  protected static native WritableMap tokenize(long contextPtr, String text, String[] mediaPaths);
+
+  // TTS/Vocoder native methods
+  protected static native boolean initVocoder(long contextPtr, String vocoderModelPath);
+  protected static native boolean isVocoderEnabled(long contextPtr);
+  protected static native int getTTSType(long contextPtr);
+  protected static native String getFormattedAudioCompletion(long contextPtr, String speakerJsonStr, String textToSpeak);
+  protected static native WritableArray getAudioCompletionGuideTokens(long contextPtr, String textToSpeak);
+  protected static native WritableArray decodeAudioTokens(long contextPtr, int[] tokens);
+  protected static native void releaseVocoder(long contextPtr);
 }

package/android/src/main/jni.cpp

@@ -255,7 +255,7 @@ Java_com_cactus_LlamaContext_initContext(
     }
 
     const char *model_path_chars = env->GetStringUTFChars(model_path_str, nullptr);
-    defaultParams.model = model_path_chars;
+    defaultParams.model.path = model_path_chars;
 
     const char *chat_template_chars = env->GetStringUTFChars(chat_template, nullptr);
     defaultParams.chat_template = chat_template_chars;
@@ -978,6 +978,134 @@ Java_com_cactus_LlamaContext_doCompletion(
     return reinterpret_cast<jobject>(result);
 }
 
+// ===== MULTIMODAL COMPLETION SUPPORT =====
+JNIEXPORT jobject JNICALL
+Java_com_cactus_LlamaContext_doMultimodalCompletion(
+    JNIEnv *env, jobject thiz, jlong context_ptr, jstring prompt, jobjectArray media_paths,
+    jint chat_format, jstring grammar, jstring json_schema, jboolean grammar_lazy,
+    jobject grammar_triggers, jobject preserved_tokens, jfloat temperature, jint n_threads,
+    jint n_predict, jint n_probs, jint penalty_last_n, jfloat penalty_repeat,
+    jfloat penalty_freq, jfloat penalty_present, jfloat mirostat, jfloat mirostat_tau,
+    jfloat mirostat_eta, jint top_k, jfloat top_p, jfloat min_p, jfloat xtc_threshold,
+    jfloat xtc_probability, jfloat typical_p, jint seed, jobjectArray stop,
+    jboolean ignore_eos, jobjectArray logit_bias, jfloat dry_multiplier, jfloat dry_base,
+    jint dry_allowed_length, jint dry_penalty_last_n, jfloat top_n_sigma,
+    jobjectArray dry_sequence_breakers, jobject partial_completion_callback) {
+    
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+
+    if (!llama->isMultimodalEnabled()) {
+        auto result = createWriteableMap(env);
+        putString(env, result, "error", "Multimodal is not enabled");
+        return reinterpret_cast<jobject>(result);
+    }
+
+    // Set all parameters (same as regular doCompletion)
+    const char *prompt_chars = env->GetStringUTFChars(prompt, nullptr);
+    llama->params.prompt = prompt_chars;
+    llama->params.sampling.seed = seed == -1 ? LLAMA_DEFAULT_SEED : seed;
+    llama->params.cpuparams.n_threads = n_threads;
+    llama->params.n_predict = n_predict;
+    llama->params.sampling.ignore_eos = ignore_eos;
+
+    auto & sparams = llama->params.sampling;
+    sparams.temp = temperature;
+    sparams.n_probs = n_probs;
+    sparams.penalty_last_n = penalty_last_n;
+    sparams.penalty_repeat = penalty_repeat;
+    sparams.penalty_freq = penalty_freq;
+    sparams.penalty_present = penalty_present;
+    sparams.mirostat = mirostat;
+    sparams.mirostat_tau = mirostat_tau;
+    sparams.mirostat_eta = mirostat_eta;
+    sparams.top_k = top_k;
+    sparams.top_p = top_p;
+    sparams.min_p = min_p;
+    sparams.xtc_threshold = xtc_threshold;
+    sparams.xtc_probability = xtc_probability;
+    sparams.typ_p = typical_p;
+
+    // Convert media paths
+    std::vector<std::string> media_paths_vector;
+    if (media_paths != nullptr) {
+        jsize media_paths_len = env->GetArrayLength(media_paths);
+        for (jsize i = 0; i < media_paths_len; i++) {
+            jstring media_path = (jstring) env->GetObjectArrayElement(media_paths, i);
+            if (media_path != nullptr) {
+                const char *media_path_chars = env->GetStringUTFChars(media_path, nullptr);
+                media_paths_vector.push_back(std::string(media_path_chars));
+                env->ReleaseStringUTFChars(media_path, media_path_chars);
+                env->DeleteLocalRef(media_path);
+            }
+        }
+    }
+
+    // Initialize sampling and begin completion with media
+    if (!llama->initSampling()) {
+        auto result = createWriteableMap(env);
+        putString(env, result, "error", "Failed to initialize sampling");
+        env->ReleaseStringUTFChars(prompt, prompt_chars);
+        return reinterpret_cast<jobject>(result);
+    }
+    
+    llama->beginCompletion();
+    
+    try {
+        llama->loadPrompt(media_paths_vector);  // Use media-aware loadPrompt
+    } catch (const std::exception& e) {
+        auto result = createWriteableMap(env);
+        putString(env, result, "error", e.what());
+        env->ReleaseStringUTFChars(prompt, prompt_chars);
+        return reinterpret_cast<jobject>(result);
+    }
+
+    // Rest of completion logic (same as doCompletion but simplified for key parts)
+    size_t sent_count = 0;
+    while (llama->has_next_token && !llama->is_interrupted) {
+        const cactus::completion_token_output token_with_probs = llama->doCompletion();
+        if (token_with_probs.tok == -1 || llama->incomplete) {
+            continue;
+        }
+
+        const std::string token_text = common_token_to_piece(llama->ctx, token_with_probs.tok);
+        size_t pos = std::min(sent_count, llama->generated_text.size());
+        const std::string str_test = llama->generated_text.substr(pos);
+        
+        size_t stop_pos = llama->findStoppingStrings(str_test, token_text.size(), cactus::STOP_FULL);
+        
+        if (stop_pos == std::string::npos || (!llama->has_next_token && stop_pos > 0)) {
+            const std::string to_send = llama->generated_text.substr(pos, std::string::npos);
+            sent_count += to_send.size();
+
+            if (partial_completion_callback != nullptr) {
+                auto tokenResult = createWriteableMap(env);
+                putString(env, tokenResult, "token", to_send.c_str());
+                
+                jclass cb_class = env->GetObjectClass(partial_completion_callback);
+                jmethodID onPartialCompletion = env->GetMethodID(cb_class, "onPartialCompletion", "(Lcom/facebook/react/bridge/WritableMap;)V");
+                env->CallVoidMethod(partial_completion_callback, onPartialCompletion, tokenResult);
+            }
+        }
+    }
+
+    llama->is_predicting = false;
+    
+    auto result = createWriteableMap(env);
+    putString(env, result, "text", llama->generated_text.c_str());
+    putInt(env, result, "tokens_predicted", llama->num_tokens_predicted);
+    putInt(env, result, "tokens_evaluated", llama->num_prompt_tokens);
+    putInt(env, result, "truncated", llama->truncated);
+    putInt(env, result, "stopped_eos", llama->stopped_eos);
+    putInt(env, result, "stopped_word", llama->stopped_word);
+    putInt(env, result, "stopped_limit", llama->stopped_limit);
+    putString(env, result, "stopping_word", llama->stopping_word.c_str());
+    putInt(env, result, "tokens_cached", llama->n_past);
+
+    env->ReleaseStringUTFChars(prompt, prompt_chars);
+    return reinterpret_cast<jobject>(result);
+}
+
 JNIEXPORT void JNICALL
 Java_com_cactus_LlamaContext_stopCompletion(
         JNIEnv *env, jobject thiz, jlong context_ptr) {
@@ -998,21 +1126,58 @@ Java_com_cactus_LlamaContext_isPredicting(
 
 JNIEXPORT jobject JNICALL
 Java_com_cactus_LlamaContext_tokenize(
-        JNIEnv *env, jobject thiz, jlong context_ptr, jstring text) {
+        JNIEnv *env, jobject thiz, jlong context_ptr, jstring text, jobjectArray media_paths) {
     UNUSED(thiz);
     auto llama = context_map[(long) context_ptr];
 
     const char *text_chars = env->GetStringUTFChars(text, nullptr);
+    
+    std::vector<std::string> media_paths_vector;
+    if (media_paths != nullptr) {
+        jsize media_paths_len = env->GetArrayLength(media_paths);
+        for (jsize i = 0; i < media_paths_len; i++) {
+            jstring media_path = (jstring) env->GetObjectArrayElement(media_paths, i);
+            if (media_path != nullptr) {
+                const char *media_path_chars = env->GetStringUTFChars(media_path, nullptr);
+                media_paths_vector.push_back(std::string(media_path_chars));
+                env->ReleaseStringUTFChars(media_path, media_path_chars);
+                env->DeleteLocalRef(media_path);
+            }
+        }
+    }
 
-    const std::vector<llama_token> toks = common_tokenize(
-        llama->ctx,
-        text_chars,
-        false
-    );
+    cactus::cactus_tokenize_result tokenize_result = llama->tokenize(text_chars, media_paths_vector);
 
-    jobject result = createWritableArray(env);
-    for (const auto &tok : toks) {
-      pushInt(env, result, tok);
+    auto result = createWriteableMap(env);
+    
+    // Add tokens array
+    auto tokens_array = createWritableArray(env);
+    for (const auto &tok : tokenize_result.tokens) {
+        pushInt(env, tokens_array, tok);
+    }
+    putArray(env, result, "tokens", tokens_array);
+    
+    // Add media info if present
+    putBoolean(env, result, "has_media", tokenize_result.has_media);
+    
+    if (tokenize_result.has_media) {
+        auto bitmap_hashes_array = createWritableArray(env);
+        for (const auto &hash : tokenize_result.bitmap_hashes) {
+            pushString(env, bitmap_hashes_array, hash.c_str());
+        }
+        putArray(env, result, "bitmap_hashes", bitmap_hashes_array);
+        
+        auto chunk_pos_array = createWritableArray(env);
+        for (const auto &pos : tokenize_result.chunk_pos) {
+            pushInt(env, chunk_pos_array, static_cast<int>(pos));
+        }
+        putArray(env, result, "chunk_pos", chunk_pos_array);
+        
+        auto chunk_pos_media_array = createWritableArray(env);
+        for (const auto &pos : tokenize_result.chunk_pos_media) {
+            pushInt(env, chunk_pos_media_array, static_cast<int>(pos));
+        }
+        putArray(env, result, "chunk_pos_media", chunk_pos_media_array);
     }
 
     env->ReleaseStringUTFChars(text, text_chars);
@@ -1179,6 +1344,156 @@ Java_com_cactus_LlamaContext_freeContext(
     delete llama;
 }
 
+// ===== MULTIMODAL SUPPORT =====
+JNIEXPORT jboolean JNICALL
+Java_com_cactus_LlamaContext_initMultimodal(
+        JNIEnv *env, jobject thiz, jlong context_ptr, jstring mmproj_path, jboolean use_gpu) {
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    
+    const char *mmproj_path_chars = env->GetStringUTFChars(mmproj_path, nullptr);
+    bool result = llama->initMultimodal(mmproj_path_chars, use_gpu);
+    env->ReleaseStringUTFChars(mmproj_path, mmproj_path_chars);
+    
+    return result;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_cactus_LlamaContext_isMultimodalEnabled(
+        JNIEnv *env, jobject thiz, jlong context_ptr) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    return llama->isMultimodalEnabled();
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_cactus_LlamaContext_isMultimodalSupportVision(
+        JNIEnv *env, jobject thiz, jlong context_ptr) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    return llama->isMultimodalSupportVision();
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_cactus_LlamaContext_isMultimodalSupportAudio(
+        JNIEnv *env, jobject thiz, jlong context_ptr) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    return llama->isMultimodalSupportAudio();
+}
+
+JNIEXPORT void JNICALL
+Java_com_cactus_LlamaContext_releaseMultimodal(
+        JNIEnv *env, jobject thiz, jlong context_ptr) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    llama->releaseMultimodal();
+}
+
+// ===== TTS/VOCODER SUPPORT =====
+JNIEXPORT jboolean JNICALL
+Java_com_cactus_LlamaContext_initVocoder(
+        JNIEnv *env, jobject thiz, jlong context_ptr, jstring vocoder_model_path) {
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    
+    const char *vocoder_path_chars = env->GetStringUTFChars(vocoder_model_path, nullptr);
+    bool result = llama->initVocoder(vocoder_path_chars);
+    env->ReleaseStringUTFChars(vocoder_model_path, vocoder_path_chars);
+    
+    return result;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_cactus_LlamaContext_isVocoderEnabled(
+        JNIEnv *env, jobject thiz, jlong context_ptr) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    return llama->isVocoderEnabled();
+}
+
+JNIEXPORT jint JNICALL
+Java_com_cactus_LlamaContext_getTTSType(
+        JNIEnv *env, jobject thiz, jlong context_ptr) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    return static_cast<jint>(llama->getTTSType());
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_cactus_LlamaContext_getFormattedAudioCompletion(
+        JNIEnv *env, jobject thiz, jlong context_ptr, jstring speaker_json_str, jstring text_to_speak) {
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    
+    const char *speaker_chars = env->GetStringUTFChars(speaker_json_str, nullptr);
+    const char *text_chars = env->GetStringUTFChars(text_to_speak, nullptr);
+    
+    std::string result = llama->getFormattedAudioCompletion(speaker_chars, text_chars);
+    
+    env->ReleaseStringUTFChars(speaker_json_str, speaker_chars);
+    env->ReleaseStringUTFChars(text_to_speak, text_chars);
+    
+    return env->NewStringUTF(result.c_str());
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_cactus_LlamaContext_getAudioCompletionGuideTokens(
+        JNIEnv *env, jobject thiz, jlong context_ptr, jstring text_to_speak) {
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    
+    const char *text_chars = env->GetStringUTFChars(text_to_speak, nullptr);
+    std::vector<llama_token> tokens = llama->getAudioCompletionGuideTokens(text_chars);
+    env->ReleaseStringUTFChars(text_to_speak, text_chars);
+    
+    jobject result = createWritableArray(env);
+    for (const auto &token : tokens) {
+        pushInt(env, result, token);
+    }
+    
+    return result;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_cactus_LlamaContext_decodeAudioTokens(
+        JNIEnv *env, jobject thiz, jlong context_ptr, jintArray tokens) {
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    
+    jsize tokens_len = env->GetArrayLength(tokens);
+    jint *tokens_ptr = env->GetIntArrayElements(tokens, 0);
+    std::vector<llama_token> token_vector;
+    for (int i = 0; i < tokens_len; i++) {
+        token_vector.push_back(tokens_ptr[i]);
+    }
+    env->ReleaseIntArrayElements(tokens, tokens_ptr, 0);
+    
+    std::vector<float> audio_data = llama->decodeAudioTokens(token_vector);
+    
+    jobject result = createWritableArray(env);
+    for (const auto &sample : audio_data) {
+        pushDouble(env, result, static_cast<double>(sample));
+    }
+    
+    return result;
+}
+
+JNIEXPORT void JNICALL
+Java_com_cactus_LlamaContext_releaseVocoder(
+        JNIEnv *env, jobject thiz, jlong context_ptr) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    llama->releaseVocoder();
+}
+
 struct log_callback_context {
     JavaVM *jvm;
     jobject callback;