cui-llama.rn 1.7.4 → 1.7.6

package/android/src/main/java/com/rnllama/RNLlama.java

@@ -16,6 +16,7 @@ import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.Arguments;
 
 
@@ -494,6 +495,38 @@ public class RNLlama implements LifecycleEventListener {
     tasks.put(task, "embedding-" + contextId);
   }
 
+  public void rerank(double id, final String query, final ReadableArray documents, final ReadableMap params, final Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, WritableArray>() {
+      private Exception exception;
+
+      @Override
+      protected WritableArray doInBackground(Void... voids) {
+        try {
+          LlamaContext context = contexts.get(contextId);
+          if (context == null) {
+            throw new Exception("Context not found");
+          }
+          return context.getRerank(query, documents, params);
+        } catch (Exception e) {
+          exception = e;
+        }
+        return null;
+      }
+
+      @Override
+      protected void onPostExecute(WritableArray result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(result);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "rerank-" + contextId);
+  }
+
   public void bench(double id, final double pp, final double tg, final double pl, final double nr, final Promise promise) {
     final int contextId = (int) id;
     AsyncTask task = new AsyncTask<Void, Void, String>() {
@@ -759,6 +792,210 @@ public class RNLlama implements LifecycleEventListener {
     tasks.put(task, "releaseMultimodal" + id);
   }
 
+  public void initVocoder(double id, final String vocoderModelPath, final Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, Boolean>() {
+      private Exception exception;
+
+      @Override
+      protected Boolean doInBackground(Void... voids) {
+        try {
+          LlamaContext context = contexts.get(contextId);
+          if (context == null) {
+            throw new Exception("Context not found");
+          }
+          if (context.isPredicting()) {
+            throw new Exception("Context is busy");
+          }
+          return context.initVocoder(vocoderModelPath);
+        } catch (Exception e) {
+          exception = e;
+        }
+        return false;
+      }
+
+      @Override
+      protected void onPostExecute(Boolean result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(result);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "initVocoder-" + contextId);
+  }
+
+  public void releaseVocoder(double id, final Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, Void>() {
+      private Exception exception;
+
+      @Override
+      protected Void doInBackground(Void... voids) {
+        try {
+          LlamaContext context = contexts.get(contextId);
+          if (context == null) {
+            throw new Exception("Context not found");
+          }
+          context.releaseVocoder();
+        } catch (Exception e) {
+          exception = e;
+        }
+        return null;
+      }
+
+      @Override
+      protected void onPostExecute(Void result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(null);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "releaseVocoder-" + contextId);
+  }
+
+  public void isVocoderEnabled(double id, final Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, Boolean>() {
+      private Exception exception;
+
+      @Override
+      protected Boolean doInBackground(Void... voids) {
+        try {
+          LlamaContext context = contexts.get(contextId);
+          if (context == null) {
+            throw new Exception("Context not found");
+          }
+          return context.isVocoderEnabled();
+        } catch (Exception e) {
+          exception = e;
+        }
+        return false;
+      }
+
+      @Override
+      protected void onPostExecute(Boolean result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(result);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "isVocoderEnabled-" + contextId);
+  }
+
+  public void getFormattedAudioCompletion(double id, final String speakerJsonStr, final String textToSpeak, Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, String>() {
+      private Exception exception;
+
+      @Override
+      protected String doInBackground(Void... voids) {
+        try {
+          LlamaContext context = contexts.get(contextId);
+          if (context == null) {
+            throw new Exception("Context not found");
+          }
+          if (!context.isVocoderEnabled()) {
+            throw new Exception("Vocoder is not enabled");
+          }
+          return context.getFormattedAudioCompletion(speakerJsonStr, textToSpeak);
+        } catch (Exception e) {
+          exception = e;
+          return null;
+        }
+      }
+
+      @Override
+      protected void onPostExecute(String result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(result);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "getFormattedAudioCompletion-" + contextId);
+  }
+
+  public void getAudioCompletionGuideTokens(double id, final String textToSpeak, final Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, WritableArray>() {
+      private Exception exception;
+
+      @Override
+      protected WritableArray doInBackground(Void... voids) {
+        try {
+          LlamaContext context = contexts.get(contextId);
+          if (context == null) {
+            throw new Exception("Context not found");
+          }
+          if (!context.isVocoderEnabled()) {
+            throw new Exception("Vocoder is not enabled");
+          }
+          return context.getAudioCompletionGuideTokens(textToSpeak);
+        } catch (Exception e) {
+          exception = e;
+          return null;
+        }
+      }
+
+      @Override
+      protected void onPostExecute(WritableArray result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(result);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "getAudioCompletionGuideTokens-" + contextId);
+  }
+
+  public void decodeAudioTokens(double id, final ReadableArray tokens, final Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, WritableArray>() {
+      private Exception exception;
+
+      @Override
+      protected WritableArray doInBackground(Void... voids) {
+        try {
+          LlamaContext context = contexts.get(contextId);
+          if (context == null) {
+            throw new Exception("Context not found");
+          }
+          if (!context.isVocoderEnabled()) {
+            throw new Exception("Vocoder is not enabled");
+          }
+          return context.decodeAudioTokens(tokens);
+        } catch (Exception e) {
+          exception = e;
+        }
+        return null;
+      }
+
+      @Override
+      protected void onPostExecute(WritableArray result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(result);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "decodeAudioTokens-" + contextId);
+  }
+
   public void releaseContext(double id, Promise promise) {
     final int contextId = (int) id;
     AsyncTask task = new AsyncTask<Void, Void, Void>() {

package/android/src/main/jni.cpp

@@ -9,7 +9,7 @@
 #include <string>
 #include <thread>
 #include <unordered_map>
-#include "json.hpp"
+#include <nlohmann/json.hpp>
 #include "json-schema-to-grammar.h"
 #include "llama.h"
 #include "chat.h"
@@ -233,7 +233,6 @@ Java_com_rnllama_LlamaContext_initContext(
     jobject thiz,
     jstring model_path_str,
     jstring chat_template,
-    jstring reasoning_format,
     jboolean embedding,
     jint embd_normalize,
     jint n_ctx,
@@ -271,13 +270,6 @@ Java_com_rnllama_LlamaContext_initContext(
     const char *chat_template_chars = env->GetStringUTFChars(chat_template, nullptr);
     defaultParams.chat_template = chat_template_chars;
 
-    const char *reasoning_format_chars = env->GetStringUTFChars(reasoning_format, nullptr);
-    if (strcmp(reasoning_format_chars, "deepseek") == 0) {
-        defaultParams.reasoning_format = COMMON_REASONING_FORMAT_DEEPSEEK;
-    } else {
-        defaultParams.reasoning_format = COMMON_REASONING_FORMAT_NONE;
-    }
-
     defaultParams.n_ctx = n_ctx;
     defaultParams.n_batch = n_batch;
     defaultParams.n_ubatch = n_ubatch;
@@ -346,7 +338,6 @@ Java_com_rnllama_LlamaContext_initContext(
 
     env->ReleaseStringUTFChars(model_path_str, model_path_chars);
     env->ReleaseStringUTFChars(chat_template, chat_template_chars);
-    env->ReleaseStringUTFChars(reasoning_format, reasoning_format_chars);
     env->ReleaseStringUTFChars(cache_type_k, cache_type_k_chars);
     env->ReleaseStringUTFChars(cache_type_v, cache_type_v_chars);
 
@@ -493,7 +484,8 @@ Java_com_rnllama_LlamaContext_getFormattedChatWithJinja(
     jstring json_schema,
     jstring tools,
     jboolean parallel_tool_calls,
-    jstring tool_choice
+    jstring tool_choice,
+    jboolean enable_thinking
 ) {
     UNUSED(thiz);
     auto llama = context_map[(long) context_ptr];
@@ -512,7 +504,8 @@ Java_com_rnllama_LlamaContext_getFormattedChatWithJinja(
             json_schema_chars,
             tools_chars,
             parallel_tool_calls,
-            tool_choice_chars
+            tool_choice_chars,
+            enable_thinking
         );
         putString(env, result, "prompt", formatted.prompt.c_str());
         putInt(env, result, "chat_format", static_cast<int>(formatted.format));
@@ -526,6 +519,7 @@ Java_com_rnllama_LlamaContext_getFormattedChatWithJinja(
             putInt(env, trigger_map, "token", trigger.token);
             pushMap(env, grammar_triggers, trigger_map);
         }
+        putBoolean(env, result, "thinking_forced_open", formatted.thinking_forced_open);
         putArray(env, result, "grammar_triggers", grammar_triggers);
         auto preserved_tokens = createWritableArray(env);
         for (const auto &token : formatted.preserved_tokens) {
@@ -537,7 +531,7 @@ Java_com_rnllama_LlamaContext_getFormattedChatWithJinja(
             pushString(env, additional_stops, stop.c_str());
         }
         putArray(env, result, "additional_stops", additional_stops);
-    } catch (const nlohmann::json_abi_v3_11_3::detail::parse_error& e) {
+    } catch (const nlohmann::json_abi_v3_12_0::detail::parse_error& e) {
         std::string errorMessage = "JSON parse error in getFormattedChat: " + std::string(e.what());
         putString(env, result, "_error", errorMessage.c_str());
         LOGI("[RNLlama] %s", errorMessage.c_str());
@@ -668,18 +662,33 @@ static inline jobject tokenProbsToMap(
     return result;
 }
 
+static inline jobject tokensToArray(
+    JNIEnv *env,
+    rnllama::llama_rn_context *llama,
+    std::vector<llama_token> tokens
+) {
+    auto result = createWritableArray(env);
+    for (const auto &token : tokens) {
+        pushInt(env, result, token);
+    }
+    return result;
+}
+
 JNIEXPORT jobject JNICALL
 Java_com_rnllama_LlamaContext_doCompletion(
     JNIEnv *env,
     jobject thiz,
     jlong context_ptr,
     jstring prompt,
+    jintArray guide_tokens,
     jint chat_format,
+    jstring reasoning_format,
     jstring grammar,
     jstring json_schema,
     jboolean grammar_lazy,
     jobject grammar_triggers,
     jobject preserved_tokens,
+    jboolean thinking_forced_open,
     jfloat temperature,
     jint n_threads,
     jint n_predict,
@@ -722,6 +731,18 @@ Java_com_rnllama_LlamaContext_doCompletion(
     // Set the prompt parameter
     llama->params.prompt = prompt_chars;
 
+    // Set the guide tokens parameter
+    if (guide_tokens != nullptr) {
+        int guide_tokens_size = env->GetArrayLength(guide_tokens);
+        int *guide_tokens_array = env->GetIntArrayElements(guide_tokens, nullptr);
+        std::vector<llama_token> guide_tokens_vector(guide_tokens_size);
+        for (int i = 0; i < guide_tokens_size; i++) {
+            guide_tokens_vector[i] = guide_tokens_array[i];
+        }
+        env->ReleaseIntArrayElements(guide_tokens, guide_tokens_array, 0);
+        llama->setGuideTokens(guide_tokens_vector);
+    }
+
     // Process image paths if provided
     std::vector<std::string> media_paths_vector;
 
@@ -908,6 +929,11 @@ Java_com_rnllama_LlamaContext_doCompletion(
         auto result = createWriteableMap(env);
         putString(env, result, "error", e.what());
         return reinterpret_cast<jobject>(result);
+    } catch (const std::runtime_error& e) {
+        llama->endCompletion();
+        auto result = createWriteableMap(env);
+        putString(env, result, "error", e.what());
+        return reinterpret_cast<jobject>(result);
     }
 
     if (llama->context_full) {
@@ -993,7 +1019,24 @@ Java_com_rnllama_LlamaContext_doCompletion(
     auto toolCallsSize = 0;
     if (!llama->is_interrupted) {
         try {
-            common_chat_msg message = common_chat_parse(llama->generated_text, static_cast<common_chat_format>(chat_format));
+            common_chat_syntax chat_syntax;
+            chat_syntax.format = static_cast<common_chat_format>(chat_format);
+
+            const char *reasoning_format_chars = env->GetStringUTFChars(reasoning_format, nullptr);
+            if (strcmp(reasoning_format_chars, "deepseek") == 0) {
+                chat_syntax.reasoning_format = COMMON_REASONING_FORMAT_DEEPSEEK;
+            } else if (strcmp(reasoning_format_chars, "deepseek-legacy") == 0) {
+                chat_syntax.reasoning_format = COMMON_REASONING_FORMAT_DEEPSEEK_LEGACY;
+            } else {
+                chat_syntax.reasoning_format = COMMON_REASONING_FORMAT_NONE;
+            }
+            chat_syntax.thinking_forced_open = thinking_forced_open;
+            env->ReleaseStringUTFChars(reasoning_format, reasoning_format_chars);
+            common_chat_msg message = common_chat_parse(
+              llama->generated_text,
+              false,
+              chat_syntax
+            );
             if (!message.reasoning_content.empty()) {
                 reasoningContent = message.reasoning_content;
             }
@@ -1027,6 +1070,7 @@ Java_com_rnllama_LlamaContext_doCompletion(
     if (toolCallsSize > 0) {
         putArray(env, result, "tool_calls", toolCalls);
     }
+    putArray(env, result, "audio_tokens", tokensToArray(env, llama, llama->audio_tokens));
     putArray(env, result, "completion_probabilities", tokenProbsToMap(env, llama, llama->generated_token_probs));
     putInt(env, result, "tokens_predicted", llama->num_tokens_predicted);
     putInt(env, result, "tokens_evaluated", llama->num_prompt_tokens);
@@ -1189,6 +1233,9 @@ Java_com_rnllama_LlamaContext_embedding(
     } catch (const std::exception &e) {
         putString(env, result, "error", e.what());
         return reinterpret_cast<jobject>(result);
+    } catch (const std::runtime_error& e) {
+        putString(env, result, "error", e.what());
+        return reinterpret_cast<jobject>(result);
     }
     llama->doCompletion();
 
@@ -1210,6 +1257,54 @@ Java_com_rnllama_LlamaContext_embedding(
     return result;
 }
 
+JNIEXPORT jobject JNICALL
+Java_com_rnllama_LlamaContext_rerank(
+        JNIEnv *env, jobject thiz,
+        jlong context_ptr,
+        jstring query,
+        jobjectArray documents,
+        jint normalize
+) {
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+
+    const char *query_chars = env->GetStringUTFChars(query, nullptr);
+
+    // Convert Java string array to C++ vector
+    std::vector<std::string> documents_vector;
+    int documents_size = env->GetArrayLength(documents);
+    for (int i = 0; i < documents_size; i++) {
+        jstring document = (jstring) env->GetObjectArrayElement(documents, i);
+        const char *document_chars = env->GetStringUTFChars(document, nullptr);
+        documents_vector.push_back(document_chars);
+        env->ReleaseStringUTFChars(document, document_chars);
+    }
+
+    auto result = createWritableArray(env);
+
+    try {
+        std::vector<float> scores = llama->rerank(query_chars, documents_vector);
+
+        for (size_t i = 0; i < scores.size(); i++) {
+            auto item = createWriteableMap(env);
+            putDouble(env, item, "score", (double) scores[i]);
+            putInt(env, item, "index", (int) i);
+            pushMap(env, result, item);
+        }
+    } catch (const std::exception &e) {
+        auto error_item = createWriteableMap(env);
+        putString(env, error_item, "error", e.what());
+        pushMap(env, result, error_item);
+    } catch (const std::runtime_error& e) {
+        auto error_item = createWriteableMap(env);
+        putString(env, error_item, "error", e.what());
+        pushMap(env, result, error_item);
+    }
+
+    env->ReleaseStringUTFChars(query, query_chars);
+    return result;
+}
+
 JNIEXPORT jstring JNICALL
 Java_com_rnllama_LlamaContext_bench(
     JNIEnv *env,
@@ -1415,4 +1510,108 @@ Java_com_rnllama_LlamaContext_releaseMultimodal(
     llama->releaseMultimodal();
 }
 
+JNIEXPORT jboolean JNICALL
+Java_com_rnllama_LlamaContext_initVocoder(
+    JNIEnv *env,
+    jobject thiz,
+    jlong context_ptr,
+    jstring vocoder_model_path
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    const char *vocoder_model_path_chars = env->GetStringUTFChars(vocoder_model_path, nullptr);
+    bool result = llama->initVocoder(vocoder_model_path_chars);
+    env->ReleaseStringUTFChars(vocoder_model_path, vocoder_model_path_chars);
+    return result;
+}
+
+JNIEXPORT void JNICALL
+Java_com_rnllama_LlamaContext_releaseVocoder(
+    JNIEnv *env,
+    jobject thiz,
+    jlong context_ptr
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    llama->releaseVocoder();
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_rnllama_LlamaContext_isVocoderEnabled(
+    JNIEnv *env,
+    jobject thiz,
+    jlong context_ptr
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    return llama->isVocoderEnabled();
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_rnllama_LlamaContext_getFormattedAudioCompletion(
+    JNIEnv *env,
+    jobject thiz,
+    jlong context_ptr,
+    jstring speaker_json_str,
+    jstring text_to_speak
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    const char *speaker_json_str_chars = env->GetStringUTFChars(speaker_json_str, nullptr);
+    const char *text_to_speak_chars = env->GetStringUTFChars(text_to_speak, nullptr);
+    std::string result = llama->getFormattedAudioCompletion(speaker_json_str_chars, text_to_speak_chars);
+    env->ReleaseStringUTFChars(speaker_json_str, speaker_json_str_chars);
+    env->ReleaseStringUTFChars(text_to_speak, text_to_speak_chars);
+    return env->NewStringUTF(result.c_str());
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_rnllama_LlamaContext_getAudioCompletionGuideTokens(
+    JNIEnv *env,
+    jobject thiz,
+    jlong context_ptr,
+    jstring text_to_speak
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    const char *text_to_speak_chars = env->GetStringUTFChars(text_to_speak, nullptr);
+    std::vector<llama_token> guide_tokens = llama->getAudioCompletionGuideTokens(text_to_speak_chars);
+    env->ReleaseStringUTFChars(text_to_speak, text_to_speak_chars);
+    auto result = createWritableArray(env);
+    for (const auto &val : guide_tokens) {
+        pushInt(env, result, (int) val);
+    }
+    return result;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_rnllama_LlamaContext_decodeAudioTokens(
+    JNIEnv *env,
+    jobject thiz,
+    jlong context_ptr,
+    jintArray tokens
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    auto llama = context_map[(long) context_ptr];
+    jsize tokens_size = env->GetArrayLength(tokens);
+    jint *tokens_ptr = env->GetIntArrayElements(tokens, nullptr);
+    std::vector<llama_token> tokens_vec(tokens_size);
+    for (int i = 0; i < tokens_size; i++) {
+        tokens_vec[i] = tokens_ptr[i];
+    }
+    env->ReleaseIntArrayElements(tokens, tokens_ptr, 0);
+    std::vector<float> audio = llama->decodeAudioTokens(tokens_vec);
+    auto result = createWritableArray(env);
+    for (const auto &val : audio) {
+      pushDouble(env, result, (double) val);
+    }
+    return result;
+}
+
 } // extern "C"

package/android/src/newarch/java/com/rnllama/RNLlamaModule.java

@@ -123,6 +123,11 @@ public class RNLlamaModule extends NativeRNLlamaSpec {
     rnllama.embedding(id, text, params, promise);
   }
 
+  @ReactMethod
+  public void rerank(double id, final String query, final ReadableArray documents, final ReadableMap params, final Promise promise) {
+    rnllama.rerank(id, query, documents, params, promise);
+  }
+
   @ReactMethod
   public void bench(double id, final double pp, final double tg, final double pl, final double nr, final Promise promise) {
     rnllama.bench(id, pp, tg, pl, nr, promise);
@@ -143,6 +148,36 @@ public class RNLlamaModule extends NativeRNLlamaSpec {
     rnllama.getLoadedLoraAdapters(id, promise);
   }
 
+  @ReactMethod
+  public void initVocoder(double id, final String vocoderModelPath, final Promise promise) {
+    rnllama.initVocoder(id, vocoderModelPath, promise);
+  }
+
+  @ReactMethod
+  public void isVocoderEnabled(double id, final Promise promise) {
+    rnllama.isVocoderEnabled(id, promise);
+  }
+
+  @ReactMethod
+  public void getFormattedAudioCompletion(double id, final String speakerJsonStr, final String textToSpeak, final Promise promise) {
+    rnllama.getFormattedAudioCompletion(id, speakerJsonStr, textToSpeak, promise);
+  }
+
+  @ReactMethod
+  public void getAudioCompletionGuideTokens(double id, final String textToSpeak, final Promise promise) {
+    rnllama.getAudioCompletionGuideTokens(id, textToSpeak, promise);
+  }
+
+  @ReactMethod
+  public void decodeAudioTokens(double id, final ReadableArray tokens, final Promise promise) {
+    rnllama.decodeAudioTokens(id, tokens, promise);
+  }
+
+  @ReactMethod
+  public void releaseVocoder(double id, final Promise promise) {
+    rnllama.releaseVocoder(id, promise);
+  }
+
   @ReactMethod
   public void releaseContext(double id, Promise promise) {
     rnllama.releaseContext(id, promise);