react-native-litert-lm 0.3.6 → 0.4.0

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM.kt

@@ -17,6 +17,7 @@ import com.google.ai.edge.litertlm.Engine
 import com.google.ai.edge.litertlm.Conversation
 import com.google.ai.edge.litertlm.EngineConfig
 import com.google.ai.edge.litertlm.ConversationConfig
+import com.google.ai.edge.litertlm.SamplerConfig
 import com.margelo.nitro.dev.litert.litertlm.Backend
 import com.margelo.nitro.dev.litert.litertlm.GenerationStats
 import com.margelo.nitro.dev.litert.litertlm.HybridLiteRTLMSpec
@@ -25,6 +26,15 @@ import com.margelo.nitro.dev.litert.litertlm.Message
 import com.margelo.nitro.dev.litert.litertlm.Role
 import com.margelo.nitro.core.Promise
 import com.google.ai.edge.litertlm.Content
+import com.google.ai.edge.litertlm.Contents
+import com.google.ai.edge.litertlm.ExperimentalApi
+import com.google.ai.edge.litertlm.ExperimentalFlags
+import com.google.ai.edge.litertlm.OpenApiTool
+import com.google.ai.edge.litertlm.ToolProvider
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
 
 
 // Alias to avoid confusion with our generated Message type
@@ -42,13 +52,26 @@ internal class StreamingCallbackListener(
     private val onToken: (String, Boolean) -> Unit,
     private val responseBuilder: StringBuilder,
     private val history: MutableList<Message>,
+    private val userMessage: String,
+    private val onStatsReady: (GenerationStats) -> Unit,
 ) : com.google.ai.edge.litertlm.MessageCallback {
 
-    override fun onMessage(responseMsg: com.google.ai.edge.litertlm.Message) {
-        val chunk = responseMsg.contents.contents
+    private val startTime = System.nanoTime()
+    private var firstTokenTime = 0L
+    private var tokenCount = 0
+
+    override fun onMessage(message: com.google.ai.edge.litertlm.Message) {
+        val chunk = message.contents.contents
             .filterIsInstance<com.google.ai.edge.litertlm.Content.Text>()
             .joinToString("") { it.text }
 
+        if (firstTokenTime == 0L && chunk.isNotEmpty()) {
+            firstTokenTime = System.nanoTime()
+        }
+        if (chunk.isNotEmpty()) {
+            tokenCount++
+        }
+
         onToken(chunk, false)
 
         if (chunk.isNotEmpty()) {
@@ -60,12 +83,27 @@ internal class StreamingCallbackListener(
         onToken("", true)
         val fullResponse = responseBuilder.toString()
         history.add(Message(Role.MODEL, fullResponse))
-        Log.d("StreamingCallbackListener", "Streaming done. Length: ${fullResponse.length}")
+
+        // Compute stats using heuristic token counts (~4 chars/token)
+        val elapsedMs = (System.nanoTime() - startTime) / 1_000_000.0
+        val ttftMs = if (firstTokenTime > 0) (firstTokenTime - startTime) / 1_000_000.0 else 0.0
+        val promptTokens = userMessage.length / 4.0
+        val completionTokens = fullResponse.length / 4.0
+        onStatsReady(GenerationStats(
+            promptTokens = promptTokens,
+            completionTokens = completionTokens,
+            totalTokens = promptTokens + completionTokens,
+            timeToFirstToken = ttftMs,
+            totalTime = elapsedMs,
+            tokensPerSecond = if (elapsedMs > 0) completionTokens / (elapsedMs / 1000.0) else 0.0
+        ))
+
+        Log.d("StreamingCallbackListener", "Streaming done. Length: ${fullResponse.length}, TTFT: ${ttftMs.toLong()}ms, Total: ${elapsedMs.toLong()}ms")
     }
 
-    override fun onError(t: Throwable) {
-        Log.e("StreamingCallbackListener", "Async generation failed", t)
-        onToken("Error: ${t.message}", true)
+    override fun onError(throwable: Throwable) {
+        Log.e("StreamingCallbackListener", "Async generation failed", throwable)
+        onToken("Error: ${throwable.message}", true)
     }
 }
 
@@ -80,6 +118,10 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     companion object {
         private const val TAG = "HybridLiteRTLM"
         private val initLock = Any()
+
+        /** Cached result of OpenCL availability probe (null = not yet checked). */
+        @Volatile
+        private var openCLAvailable: Boolean? = null
         
         /**
          * Initialize the native library.
@@ -129,6 +171,8 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     private var topP: Double = 0.95
     private var maxTokens: Int = 1024
     private var systemPrompt: String? = null
+    private var tools: Array<ToolDefinition>? = null
+    private var enableSpeculativeDecoding: Boolean = false
 
     override val memorySize: Long
         get() = 1024L * 1024L * 1024L // ~1GB (models are large)
@@ -158,9 +202,43 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                     cfg.topP?.let { topP = it }
                     cfg.maxTokens?.let { maxTokens = it.toInt() }
                     cfg.systemPrompt?.let { systemPrompt = it }
+                    tools = cfg.tools
+                    enableSpeculativeDecoding = cfg.enableSpeculativeDecoding ?: false
                 }
     
+                // Whether to run engine validation after loading
+                val shouldValidate = config?.validate?: false
+    
                 try {
+                    // Early GPU hardware check: probe for OpenCL library before
+                    // spending time on engine creation. LiteRT-LM's GPU delegate
+                    // requires OpenCL, which is absent on most Samsung/Qualcomm devices.
+                    if (backend == Backend.GPU) {
+                        val hasOpenCL = openCLAvailable ?: run {
+                            val result = try {
+                                System.loadLibrary("OpenCL")
+                                true
+                            } catch (_: UnsatisfiedLinkError) {
+                                try {
+                                    // Some devices have it at a non-standard path
+                                    System.load("/system/vendor/lib64/libOpenCL.so")
+                                    true
+                                } catch (_: UnsatisfiedLinkError) {
+                                    false
+                                }
+                            }
+                            openCLAvailable = result
+                            result
+                        }
+                        if (!hasOpenCL) {
+                            throw RuntimeException(
+                                "GPU backend is not supported on this device (OpenCL library not found). " +
+                                "Please use CPU backend instead."
+                            )
+                        }
+                        Log.i(TAG, "OpenCL library found — GPU backend is available")
+                    }
+
                     // Map our Backend enum to LiteRT-LM Backend sealed class
                     val lmBackend = when (backend) {
                         Backend.GPU -> com.google.ai.edge.litertlm.Backend.GPU()
@@ -171,12 +249,12 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                         else -> com.google.ai.edge.litertlm.Backend.CPU()
                     }
                     
-                    // Detect multimodal support from model filename.
+                    // Detect multimodal support. Check config.multimodal flag first, then fall back to filename sniffing.
                     // Only Gemma 3n bundles vision/audio executors; Gemma 4 E2B is text-only.
                     // Passing vision/audio backends to a text-only model causes
                     // vision_litert_compiled_model_executor init failures.
                     val modelFileName = modelPath.substringAfterLast("/").lowercase()
-                    val isMultimodal = modelFileName.contains("3n") || modelFileName.contains("gemma3")
+                    val isMultimodal = config?.multimodal ?: (modelFileName.contains("3n") || modelFileName.contains("gemma3"))
     
                     val lmVisionBackend = if (isMultimodal) com.google.ai.edge.litertlm.Backend.GPU() else null
                     val lmAudioBackend = if (isMultimodal) com.google.ai.edge.litertlm.Backend.CPU() else null
@@ -208,6 +286,11 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     
                     if (isClosed) return@synchronized
                     
+                    if (enableSpeculativeDecoding) {
+                        @OptIn(ExperimentalApi::class)
+                        ExperimentalFlags.enableSpeculativeDecoding = true
+                    }
+
                     // Initialize Engine
                     engine = Engine(engineConfig).also { it.initialize() }
                     Log.i(TAG, "Engine created and initialized successfully")
@@ -215,9 +298,24 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                     // Create Conversation
                     createNewConversation()
                     Log.i(TAG, "Conversation created successfully")
+
+                    // Validate the engine actually works with a quick test inference.
+                    // GPU/NPU backends can initialize without error but silently fail to
+                    // produce tokens — enabling this catches those failures at load time.
+                    // CPU is always reliable so validation is never run on it, even when
+                    // the `validate` flag is set.
+                    if (shouldValidate) {
+                        if (backend == Backend.GPU || backend == Backend.NPU) {
+                            validateEngine()
+                        } else {
+                            Log.i(TAG, "Validation skipped: CPU backend is always reliable")
+                        }
+                    }
     
                 } catch (e: Exception) {
                     Log.e(TAG, "Failed to load model: ${e.message}", e)
+                    // Clean up partial state so isReady() returns false
+                    cleanupInternal()
                     throw RuntimeException("Failed to load model: ${e.message}", e)
                 }
             }
@@ -241,7 +339,7 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
             Log.i(TAG, "sendMessage (Promise): $message")
             
             // Blocking inference (safe here because we are in Promise.parallel worker thread)
-            val userMsg = LiteRTMessage.of(text = message)
+            val userMsg = LiteRTMessage.user(message)
             val startTime = System.nanoTime()
             val responseMsg = conversation!!.sendMessage(message = userMsg)
             val elapsedMs = (System.nanoTime() - startTime) / 1_000_000.0
@@ -276,30 +374,48 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     // -------------------------------------------------------------------------
     // sendMessageAsync - Streaming inference
     // -------------------------------------------------------------------------
-    override fun sendMessageAsync(message: String, onToken: (String, Boolean) -> Unit) {
-        // This is already async (void return), so we execute immediately on the calling thread
-        // (which is the Nitro specialized thread, not Main).
-        // The SDK's sendMessageAsync is non-blocking anyway.
-        ensureLoaded()
+    override fun sendMessageAsync(message: String, onToken: (String, Boolean) -> Unit): Promise<Unit> {
+        return Promise.parallel {
+            val latch = CountDownLatch(1)
+            val errorRef = AtomicReference<Throwable?>(null)
 
-        // Add user message to history
-        history.add(Message(Role.USER, message))
-        Log.d(TAG, "sendMessageAsync: $message")
+            ensureLoaded()
 
-        val fullResponseBuilder = StringBuilder()
-        
-        val listener = StreamingCallbackListener(
-            onToken = onToken,
-            responseBuilder = fullResponseBuilder,
-            history = history,
-        )
+            // Add user message to history
+            history.add(Message(Role.USER, message))
+            Log.d(TAG, "sendMessageAsync: $message")
 
-        try {
-            val userMsg = LiteRTMessage.of(text = message)
-            conversation!!.sendMessageAsync(message = userMsg, callback = listener)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to initiate async generation", e)
-            onToken("Error: ${e.message}", true)
+            val fullResponseBuilder = StringBuilder()
+            
+            val listener = StreamingCallbackListener(
+                onToken = { token, done ->
+                    onToken(token, done)
+                    if (done) {
+                        latch.countDown()
+                    }
+                },
+                responseBuilder = fullResponseBuilder,
+                history = history,
+                userMessage = message,
+                onStatsReady = { stats -> lastStats = stats },
+            )
+
+            try {
+                val userMsg = LiteRTMessage.user(message)
+                conversation!!.sendMessageAsync(message = userMsg, callback = listener)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to initiate async generation", e)
+                errorRef.set(e)
+                onToken("Error: ${e.message}", true)
+                latch.countDown()
+            }
+
+            // Wait for completion or error
+            latch.await()
+            val err = errorRef.get()
+            if (err != null) {
+                throw RuntimeException("Async inference failed: ${err.message}", err)
+            }
         }
     }
 
@@ -359,7 +475,7 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
             // Use factory method Message.of passing a list of Content
             val textContent = Content.Text(message)
             
-            val userMsg = LiteRTMessage.of(textContent, Content.ImageFile(processedImagePath))
+            val userMsg = LiteRTMessage.user(Contents.of(textContent, Content.ImageFile(processedImagePath)))
 
             // Add to history
             history.add(Message(Role.USER, "$message [Image]"))
@@ -389,6 +505,14 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         return Promise.parallel {
             Log.i(TAG, "downloadModel: $url -> $fileName")
             
+            if (!url.startsWith("https://", ignoreCase = true)) {
+                throw IllegalArgumentException("Invalid download URL: HTTPS is required for security.")
+            }
+            
+            if (fileName.contains("..") || fileName.contains("/") || fileName.contains("\\")) {
+                throw IllegalArgumentException("Invalid filename: path traversal or directory separators are not allowed.")
+            }
+            
             val context = LiteRTLMInitProvider.applicationContext ?: throw RuntimeException("Context not available")
             val modelsDir = java.io.File(context.filesDir, "models")
             if (!modelsDir.exists()) {
@@ -470,6 +594,11 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     override fun deleteModel(fileName: String): Promise<Unit> {
         return Promise.parallel {
             Log.i(TAG, "deleteModel: $fileName")
+            
+            if (fileName.contains("..") || fileName.contains("/") || fileName.contains("\\")) {
+                throw IllegalArgumentException("Invalid filename: path traversal or directory separators are not allowed.")
+            }
+            
             val context = LiteRTLMInitProvider.applicationContext ?: throw RuntimeException("Context not available")
             val modelsDir = java.io.File(context.filesDir, "models")
             val modelFile = java.io.File(modelsDir, fileName)
@@ -501,10 +630,10 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
 
             // Load audio
             
-            val userMsg = LiteRTMessage.of(
+            val userMsg = LiteRTMessage.user(Contents.of(
                 Content.Text(message),
                 Content.AudioFile(audioPath)
-            )
+            ))
 
             history.add(Message(Role.USER, "$message [Audio]"))
             
@@ -601,19 +730,9 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
 
     private fun cleanupInternal() {
         try {
+            conversation?.close()
             conversation = null
-            // Explicitly close engine if it supports it to free native memory immediately
-            // Assuming Engine implements AutoCloseable or has close()
-            if (engine is AutoCloseable) {
-                (engine as AutoCloseable).close()
-            } else {
-                 // Try reflection or just null it if no close method
-                try {
-                    engine?.javaClass?.getMethod("close")?.invoke(engine)
-                } catch (e: Exception) {
-                    // Method not found, rely on GC
-                }
-            }
+            engine?.close()        // Direct call
             engine = null 
         } catch (e: Exception) {
             Log.e(TAG, "Error closing resources", e)
@@ -631,33 +750,167 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         // v0.10.2 enforces single-session: close existing conversation first
         conversation?.let { oldConv ->
             try {
-                if (oldConv is AutoCloseable) {
-                    oldConv.close()
-                } else {
-                    oldConv.javaClass.getMethod("close").invoke(oldConv)
-                }
+                oldConv.close()
             } catch (e: Exception) {
                 Log.w(TAG, "Failed to close old conversation: ${e.message}")
             }
             conversation = null
         }
-        conversation = engine!!.createConversation()
-        // Apply system prompt/instruction if set
-        systemPrompt?.let { prompt ->
-            if (prompt.isNotEmpty()) {
-                try {
-                    // Send system instruction as the first turn to prime the conversation.
-                    // LiteRT-LM's Conversation API handles chat template formatting,
-                    // including Gemma's <start_of_turn>system block.
-                    val systemMsg = LiteRTMessage.of(Content.Text(prompt))
-                    conversation!!.sendMessage(message = systemMsg)
-                    Log.i(TAG, "System prompt applied (${prompt.length} chars)")
-                } catch (e: Exception) {
-                    Log.w(TAG, "Failed to apply system prompt: ${e.message}")
+        // Map tools
+        val lmTools: List<ToolProvider>? = tools?.map { tool ->
+            val apiTool = object : OpenApiTool {
+                override fun getToolDescriptionJsonString(): String {
+                    return tool.parametersJson
+                }
+                override fun execute(paramsJsonString: String): String {
+                    return "{}"
                 }
             }
+            (apiTool as Any) as ToolProvider
         }
+
+        // Create conversation with explicit SamplerConfig (required by Gallery pattern).
+        // GPU backend may fail silently without proper sampler params.
+        val convConfig = ConversationConfig(
+            samplerConfig = SamplerConfig(
+                topK = topK,
+                topP = topP.toDouble(),
+                temperature = temperature.toDouble(),
+            ),
+            systemInstruction = systemPrompt?.let { Contents.of(Content.Text(it)) },
+            tools = lmTools ?: emptyList()
+        )
+        conversation = engine!!.createConversation(convConfig)
     }
 
+    /**
+     * Validate that the engine can actually produce inference output.
+     *
+     * Some GPU backends initialize without error but silently hang during inference.
+     * This sends a minimal test prompt ("Hi") and waits up to 30s for any token.
+     * If no token arrives, we throw so the model does NOT appear as loaded.
+     */
+    private fun validateEngine() {
+        val backendName = when (backend) {
+            Backend.GPU -> "GPU"
+            Backend.NPU -> "NPU"
+            else -> "CPU"
+        }
+        Log.i(TAG, "Validating $backendName backend with test inference...")
+
+        val latch = CountDownLatch(1)
+        val gotToken = AtomicBoolean(false)
+        val errorRef = AtomicReference<String?>(null)
+
+        // Use the existing conversation for validation (single-session constraint).
+        val validationConv = conversation
+            ?: throw RuntimeException("$backendName backend: no conversation available for validation")
+
+        try {
+            val testMsg = LiteRTMessage.user("Hi")
+            validationConv.sendMessageAsync(
+                message = testMsg,
+                callback = object : com.google.ai.edge.litertlm.MessageCallback {
+                    override fun onMessage(msg: com.google.ai.edge.litertlm.Message) {
+                        gotToken.set(true)
+                        latch.countDown()
+                    }
+                    override fun onDone() {
+                        latch.countDown()
+                    }
+                    override fun onError(t: Throwable) {
+                        errorRef.set(t.message)
+                        latch.countDown()
+                    }
+                }
+            )
+        } catch (e: Exception) {
+            throw RuntimeException(
+                "$backendName backend failed to run inference: ${e.message}. " +
+                "This device may not support the $backendName backend. Please try CPU.",
+                e
+            )
+        }
 
+        // Wait up to 30s for any response
+        val completed = latch.await(30, TimeUnit.SECONDS)
+
+        val error = errorRef.get()
+        if (error != null) {
+            throw RuntimeException(
+                "$backendName backend inference error: $error. " +
+                "This device may not support the $backendName backend. Please try CPU."
+            )
+        }
+        if (!completed || !gotToken.get()) {
+            throw RuntimeException(
+                "$backendName backend produced no response within 30 seconds. " +
+                "This device may not support the $backendName backend. Please try CPU."
+            )
+        }
+
+        Log.i(TAG, "$backendName backend validated successfully")
+
+        // Re-create the real conversation (validation consumed one turn)
+        createNewConversation()
+    }
+
+    override fun sendMultimodalMessage(parts: Array<MultimodalPart>): Promise<String> {
+        return Promise.parallel {
+            ensureLoaded()
+            val contents = mutableListOf<Content>()
+            var userTextRepresentation = ""
+            for (part in parts) {
+                when (part.type) {
+                    PartType.TEXT -> part.text?.let { 
+                        contents.add(Content.Text(it))
+                        userTextRepresentation += "$it "
+                    }
+                    PartType.IMAGE -> part.imageBuffer?.let { buffer ->
+                        val byteBuffer = buffer.getBuffer(false)
+                        val bytes = ByteArray(byteBuffer.remaining())
+                        byteBuffer.get(bytes)
+                        contents.add(Content.ImageBytes(bytes))
+                        userTextRepresentation += "[Image Buffer] "
+                    }
+                    PartType.AUDIO -> part.audioBuffer?.let { buffer ->
+                        val byteBuffer = buffer.getBuffer(false)
+                        val bytes = ByteArray(byteBuffer.remaining())
+                        byteBuffer.get(bytes)
+                        contents.add(Content.AudioBytes(bytes))
+                        userTextRepresentation += "[Audio Buffer] "
+                    }
+                }
+            }
+            userTextRepresentation = userTextRepresentation.trim()
+            history.add(Message(Role.USER, userTextRepresentation))
+
+            val userMsg = LiteRTMessage.user(Contents.of(contents))
+            val startTime = System.nanoTime()
+            val responseMsg = conversation!!.sendMessage(message = userMsg)
+            val elapsedMs = (System.nanoTime() - startTime) / 1_000_000.0
+
+            val response = responseMsg.contents.contents
+                .filterIsInstance<Content.Text>()
+                .joinToString("") { it.text }
+
+            history.add(Message(Role.MODEL, response))
+            
+            val promptTokens = userTextRepresentation.length / 4.0
+            val completionTokens = response.length / 4.0
+            lastStats = GenerationStats(
+                promptTokens = promptTokens,
+                completionTokens = completionTokens,
+                totalTokens = promptTokens + completionTokens,
+                timeToFirstToken = 0.0,
+                totalTime = elapsedMs,
+                tokensPerSecond = if (elapsedMs > 0) completionTokens / (elapsedMs / 1000.0) else 0.0
+            )
+            response
+        }
+    }
+
+    override fun countTokens(text: String): Double {
+        return -1.0
+    }
 }

package/android/src/main/java/dev/litert/litertlm/LiteRTLMPackage.kt

@@ -1,18 +1,35 @@
 package dev.litert.litertlm
 
+import android.os.Build
+import android.util.Log
 import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
-import com.margelo.nitro.core.HybridObject
 
 
 import com.margelo.nitro.dev.litert.litertlm.LiteRTLMOnLoad
 
 class LiteRTLMPackage : TurboReactPackage() {
+    companion object {
+        private const val TAG = "LiteRTLMPackage"
+
+        private fun isSupportedPrimaryAbi(): Boolean {
+            val primaryAbi = Build.SUPPORTED_64_BIT_ABIS.firstOrNull() ?: return false
+            return primaryAbi == "arm64-v8a"
+        }
+    }
     init {
-        LiteRTLMOnLoad.initializeNative()
+        if (!isSupportedPrimaryAbi()) {
+            Log.w(TAG, "Skipping LiteRTLM native init on unsupported primary ABI: ${Build.SUPPORTED_64_BIT_ABIS.firstOrNull()}")
+        } else {
+            try {
+                LiteRTLMOnLoad.initializeNative()
+            } catch (e: UnsatisfiedLinkError) {
+                Log.e(TAG, "LiteRTLM native init failed; disabling LiteRTLM for this process.", e)
+            }
+        }
     }
 
 

package/android/src/test/java/com/margelo/nitro/core/Promise.kt

@@ -0,0 +1,46 @@
+package com.margelo.nitro.core
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+@Keep
+@DoNotStrip
+class Promise<T> {
+    companion object {
+        @JvmStatic
+        fun <T> parallel(block: () -> T): Promise<T> {
+            val promise = Promise<T>()
+            try {
+                val result = block()
+                promise.resolve(result)
+            } catch (e: Throwable) {
+                promise.reject(e)
+            }
+            return promise
+        }
+    }
+
+    var result: T? = null
+        private set
+    var error: Throwable? = null
+        private set
+    var isCompleted = false
+        private set
+    private val callbacks = mutableListOf<(T?, Throwable?) -> Unit>()
+
+    fun resolve(value: T) {
+        synchronized(this) {
+            result = value
+            isCompleted = true
+            callbacks.forEach { it(value, null) }
+        }
+    }
+
+    fun reject(exception: Throwable) {
+        synchronized(this) {
+            error = exception
+            isCompleted = true
+            callbacks.forEach { it(null, exception) }
+        }
+    }
+}