@dvai-bridge/android-litert-core 4.0.0

package/android/src/main/java/co/deepvoiceai/bridge/litert/core/LiteRTPluginState.kt

@@ -0,0 +1,199 @@
+package co.deepvoiceai.bridge.litert.core
+
+import co.deepvoiceai.bridge.litert.core.Internal.HFTokenizerJson
+import co.deepvoiceai.bridge.litert.core.Internal.LiteRTEngine
+import co.deepvoiceai.bridge.litert.core.Internal.LiteRTGenerator
+import co.deepvoiceai.bridge.litert.core.Internal.LiteRTSampler
+import co.deepvoiceai.bridge.shared.core.CorsConfig
+import co.deepvoiceai.bridge.shared.core.HandlerContext
+import co.deepvoiceai.bridge.shared.core.HttpServer
+import com.google.ai.edge.litert.Accelerator
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.random.Random
+
+/**
+ * Owns the running state of the LiteRT core: the engine, the tokenizer,
+ * the HTTP server, and model metadata. All access is serialized through
+ * a [Mutex] so concurrent start/stop calls can never race against the
+ * underlying [com.google.ai.edge.litert.CompiledModel] (whose internal
+ * KV-cache state is single-conversation by design).
+ *
+ * Capacitor-free: opts are plain `Map<String, Any?>` and return values
+ * are plain `Map<String, Any?>`. The Capacitor wrapper translates
+ * JSObject ↔ Map at the JS bridge boundary (consistent with the
+ * existing llama-core / mediapipe-core PluginState shape).
+ *
+ * Required `start()` opts:
+ *  - `modelPath`     String — absolute path to the .tflite / .litertlm file.
+ *  - `tokenizerPath` String — absolute path to the HF `tokenizer.json`.
+ *
+ * Optional `start()` opts (all have sane defaults):
+ *  - `contextSize`         Int   default 2048
+ *  - `temperature`         Float default 0.0 (greedy)
+ *  - `topP`                Float default 1.0
+ *  - `topK`                Int   default 0 (disabled)
+ *  - `maxNewTokens`        Int   default 256
+ *  - `eosTokenId`          Int   override tokenizer.json's discovered EOS
+ *  - `accelerator`         String "cpu" | "gpu" | "npu"   default "cpu"
+ *  - `chatTemplate`        String "llama3" | "plain"     default "llama3"
+ *  - `litertInputName`     String default "input_ids"
+ *  - `litertCausalMaskName` String default "causal_mask"
+ *  - `litertOutputName`    String default "logits"
+ *  - `httpBasePort`        Int   default 38883
+ *  - `httpMaxPortAttempts` Int   default 16
+ *  - `corsOrigin`          (see [CorsConfig.fromOpt])
+ *  - `samplerSeed`         Long  default System.nanoTime()
+ *  - `modelId`             String default modelPath basename
+ */
+class LiteRTPluginState {
+    private val mutex = Mutex()
+    private var server: HttpServer? = null
+    private var engine: LiteRTEngine? = null
+    private var modelId: String = ""
+    private var isRunning: Boolean = false
+    private var baseUrl: String? = null
+    private var port: Int? = null
+
+    suspend fun start(opts: Map<String, Any?>): Map<String, Any?> = mutex.withLock {
+        if (isRunning) stopInternal()
+
+        val modelPath = (opts["modelPath"] as? String)?.takeIf { it.isNotEmpty() }
+            ?: throw IllegalArgumentException("modelPath is required for litert backend")
+        val tokenizerPath = (opts["tokenizerPath"] as? String)?.takeIf { it.isNotEmpty() }
+            ?: throw IllegalArgumentException("tokenizerPath is required for litert backend")
+
+        val contextSize = (opts["contextSize"] as? Number)?.toInt() ?: 2048
+        val temperature = (opts["temperature"] as? Number)?.toFloat() ?: 0.0f
+        val topP = (opts["topP"] as? Number)?.toFloat() ?: 1.0f
+        val topK = (opts["topK"] as? Number)?.toInt() ?: 0
+        val maxNewTokens = (opts["maxNewTokens"] as? Number)?.toInt() ?: 256
+        val eosOverride = (opts["eosTokenId"] as? Number)?.toInt()
+        val acceleratorOpt = (opts["accelerator"] as? String)?.lowercase()
+        val accelerator = when (acceleratorOpt) {
+            "gpu" -> Accelerator.GPU
+            "npu" -> Accelerator.NPU
+            null, "cpu" -> Accelerator.CPU
+            else -> throw IllegalArgumentException("invalid 'accelerator' opt: $acceleratorOpt (expected cpu|gpu|npu)")
+        }
+        val chatTemplateOpt = (opts["chatTemplate"] as? String)?.lowercase()
+        val chatTemplate = when (chatTemplateOpt) {
+            null, "llama3" -> ChatTemplateRenderer.LLAMA3
+            "plain" -> ChatTemplateRenderer.PLAIN
+            else -> throw IllegalArgumentException("invalid 'chatTemplate' opt: $chatTemplateOpt (expected llama3|plain)")
+        }
+        val inputName = (opts["litertInputName"] as? String) ?: "input_ids"
+        val causalMaskName = (opts["litertCausalMaskName"] as? String) ?: "causal_mask"
+        val outputName = (opts["litertOutputName"] as? String) ?: "logits"
+        val httpBasePort = (opts["httpBasePort"] as? Number)?.toInt() ?: 38883
+        val httpMaxPortAttempts = (opts["httpMaxPortAttempts"] as? Number)?.toInt() ?: 16
+        val corsConfig = CorsConfig.fromOpt(opts["corsOrigin"])
+        val samplerSeed = (opts["samplerSeed"] as? Number)?.toLong() ?: System.nanoTime()
+        val resolvedModelId = (opts["modelId"] as? String)?.takeIf { it.isNotEmpty() }
+            ?: deriveModelId(modelPath)
+
+        // Load tokenizer FIRST so we can pick up its discovered EOS for the
+        // engine constructor. Tokenizer load failure is cheap; engine load
+        // is expensive (loads the full .tflite into memory).
+        val tokenizer = try {
+            HFTokenizerJson.load(tokenizerPath, eosTokenIdOverride = eosOverride)
+        } catch (e: LiteRTBackendError.TokenizerLoadFailed) {
+            throw e
+        }
+
+        val newEngine = try {
+            LiteRTEngine(
+                modelPath = modelPath,
+                inputName = inputName,
+                causalMaskName = causalMaskName,
+                outputName = outputName,
+                contextSize = contextSize,
+                eosTokenId = tokenizer.eosTokenId,
+                accelerator = accelerator,
+            )
+        } catch (e: LiteRTBackendError.ModelLoadFailed) {
+            throw e
+        }
+
+        val sampler = LiteRTSampler(
+            temperature = temperature,
+            topP = topP,
+            topK = topK,
+            random = Random(samplerSeed),
+        )
+        val generator = LiteRTGenerator(
+            engine = newEngine,
+            tokenizer = tokenizer,
+            sampler = sampler,
+            maxNewTokens = maxNewTokens,
+        )
+        val handlers = LiteRTHandlers(
+            generator = generator,
+            modelId = resolvedModelId,
+            chatTemplate = chatTemplate,
+            maxNewTokensDefault = maxNewTokens,
+        )
+        val ctx = HandlerContext(modelId = resolvedModelId, backendName = "litert")
+
+        val newServer = HttpServer()
+        val boundPort = try {
+            newServer.startWithRoutes(
+                basePort = httpBasePort,
+                maxAttempts = httpMaxPortAttempts,
+                host = "127.0.0.1",
+                handlers = handlers,
+                ctx = ctx,
+                corsConfig = corsConfig,
+            )
+        } catch (t: Throwable) {
+            // Bind failed — release the engine we already initialized so we
+            // don't leak the native handle.
+            runCatching { newEngine.close() }
+            throw t
+        }
+
+        this.engine = newEngine
+        this.server = newServer
+        this.modelId = resolvedModelId
+        this.port = boundPort
+        this.baseUrl = "http://127.0.0.1:$boundPort/v1"
+        this.isRunning = true
+
+        return@withLock mapOf(
+            "baseUrl" to "http://127.0.0.1:$boundPort/v1",
+            "port" to boundPort,
+            "backend" to "litert",
+            "modelId" to resolvedModelId,
+        )
+    }
+
+    suspend fun stop() = mutex.withLock { stopInternal() }
+
+    private suspend fun stopInternal() {
+        server?.stop()
+        runCatching { engine?.close() }
+        server = null
+        engine = null
+        modelId = ""
+        baseUrl = null
+        port = null
+        isRunning = false
+    }
+
+    fun statusInfo(): Map<String, Any?> = buildMap {
+        put("running", isRunning)
+        baseUrl?.let { put("baseUrl", it) }
+        if (isRunning) put("backend", "litert")
+    }
+
+    /**
+     * Best-effort default model id from a model file path: strip the
+     * directory prefix and any `.tflite` / `.litertlm` extension.
+     * Mirrors `MediaPipePluginState.deriveModelId`.
+     */
+    private fun deriveModelId(modelPath: String): String {
+        val name = modelPath.substringAfterLast('/').substringAfterLast('\\')
+        val stripped = name.removeSuffix(".tflite").removeSuffix(".litertlm")
+        return stripped.ifEmpty { "litert-default" }
+    }
+}

package/android/src/test/java/co/deepvoiceai/bridge/litert/core/Internal/LiteRTGeneratorMockTest.kt

@@ -0,0 +1,234 @@
+package co.deepvoiceai.bridge.litert.core.Internal
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import kotlin.random.Random
+
+/**
+ * Unit tests for [LiteRTGenerator]'s decode-loop control flow, using a
+ * fake [LiteRTEngineApi] that returns canned logits so we can verify:
+ *
+ *  - Tokens come out in the order the engine's logits dictate (greedy).
+ *  - EOS terminates the loop early.
+ *  - maxNewTokens caps the loop even when EOS is never produced.
+ *  - kvCachePosition is incremented monotonically across runStep calls.
+ *
+ * Tokenizer: a tiny stub that maps the prompt to a fixed token list and
+ * round-trips token ids through a vocab built off raw chars. This avoids
+ * loading a real tokenizer.json from disk in a unit test.
+ */
+class LiteRTGeneratorMockTest {
+
+    /** Records every (token, kvPos) pair the generator feeds. */
+    private class CallLog {
+        val calls = mutableListOf<Pair<Int, Int>>()
+    }
+
+    /**
+     * Fake engine: returns canned logits whose argmax is the *next*
+     * entry in [predictionsAfterPrefill] starting from the last prefill
+     * call. Earlier prefill calls return zero-vector logits — those
+     * predictions are immediately overwritten by the next prefill step,
+     * so their values are irrelevant.
+     *
+     * @param promptLen number of prefill calls the generator will make
+     *                   (= prompt token count). The fake counts down
+     *                   `promptLen` calls before it starts emitting
+     *                   meaningful argmax targets from
+     *                   [predictionsAfterPrefill][0].
+     */
+    private class FakeEngine(
+        override val vocabSize: Int,
+        override val eosTokenId: Int,
+        private val promptLen: Int,
+        private val predictionsAfterPrefill: List<Int>,
+        private val log: CallLog,
+    ) : LiteRTEngineApi {
+        private var callIdx = 0
+
+        override fun runStep(token: Int, kvCachePosition: Int): FloatArray {
+            log.calls.add(token to kvCachePosition)
+            val logits = FloatArray(vocabSize) { -10f }
+            // First (promptLen - 1) calls are early-prefill; their logits
+            // are immediately overwritten by the next prefill call so we
+            // emit no preference. Call (promptLen - 1) is the LAST prefill
+            // — its argmax is the FIRST sampled token. From there on,
+            // each runStep is a decode-feed and its argmax is the next
+            // sampled token.
+            val predictionIdx = callIdx - (promptLen - 1)
+            callIdx += 1
+            if (predictionIdx < 0) return logits
+            val target = if (predictionIdx < predictionsAfterPrefill.size) {
+                predictionsAfterPrefill[predictionIdx]
+            } else {
+                eosTokenId
+            }
+            logits[target] = 100f // dominant
+            return logits
+        }
+
+        override fun close() {}
+    }
+
+    /**
+     * Build a tokenizer over a tiny ASCII alphabet so the generator's
+     * encode + decode round-trips deterministically. We use the
+     * pure-Kotlin BPE loader's output via a synthetic JSON; that's
+     * heavier than needed here, so we provide a hand-rolled stub
+     * instead by writing a tokenizer.json to a temp file.
+     *
+     * Since the production code only depends on encode/decode, a far
+     * simpler approach is to build the tokenizer through a custom
+     * factory bypassing the JSON loader. We do that via reflection on
+     * the private constructor — but that's brittle. Instead, write a
+     * minimal valid tokenizer.json and load it normally.
+     */
+    private fun buildTinyTokenizer(eosId: Int = 99): HFTokenizerJson {
+        // Minimal tokenizer.json with BPE model and added_tokens for EOS.
+        // Vocab covers single-byte chars 'a'..'e' (which after byte-level
+        // mapping become themselves since 'a'..'e' are in the printable
+        // ASCII range 33..126) plus the EOS special.
+        val json = """
+        {
+          "model": {
+            "type": "BPE",
+            "vocab": { "a": 0, "b": 1, "c": 2, "d": 3, "e": 4 },
+            "merges": []
+          },
+          "added_tokens": [
+            { "id": $eosId, "content": "<|eot_id|>", "special": true }
+          ]
+        }
+        """.trimIndent()
+        val tmp = java.io.File.createTempFile("litert-test-tokenizer", ".json")
+        tmp.deleteOnExit()
+        tmp.writeText(json)
+        return HFTokenizerJson.load(tmp.absolutePath)
+    }
+
+    @Test
+    fun `generator emits scripted tokens in order`() = runBlocking {
+        // Prompt "abc" tokenizes to [0, 1, 2] (promptLen=3). After the
+        // last prefill step the engine predicts 3 ('d'), then 4 ('e'),
+        // then 99 (EOS). Decoded output is "de".
+        val log = CallLog()
+        val tokenizer = buildTinyTokenizer(eosId = 99)
+        val engine = FakeEngine(
+            vocabSize = 100,
+            eosTokenId = 99,
+            promptLen = 3,
+            predictionsAfterPrefill = listOf(3, 4, 99),
+            log = log,
+        )
+        val sampler = LiteRTSampler(temperature = 0f, topP = 1f, topK = 0, random = Random(42))
+        val gen = LiteRTGenerator(engine, tokenizer, sampler, maxNewTokens = 16)
+
+        val output = gen.generate("abc")
+        assertEquals("de", output)
+    }
+
+    @Test
+    fun `generator stops on EOS`() = runBlocking {
+        // promptLen=1: prompt "a" -> [0] -> single prefill call. Its
+        // argmax is EOS, so the decode loop terminates before producing
+        // any token.
+        val log = CallLog()
+        val tokenizer = buildTinyTokenizer(eosId = 99)
+        val engine = FakeEngine(
+            vocabSize = 100,
+            eosTokenId = 99,
+            promptLen = 1,
+            predictionsAfterPrefill = listOf(99),
+            log = log,
+        )
+        val sampler = LiteRTSampler(temperature = 0f, topP = 1f, topK = 0, random = Random(42))
+        val gen = LiteRTGenerator(engine, tokenizer, sampler, maxNewTokens = 99)
+
+        val output = gen.generate("a") // tokenizes to [0]
+        assertEquals("", output)
+        // Exactly one runStep call (the prefill); first sample produced
+        // EOS so the decode loop never invoked the engine again.
+        assertEquals(1, log.calls.size)
+        assertEquals(0 to 0, log.calls[0])
+    }
+
+    @Test
+    fun `generator caps at maxNewTokens when EOS never emitted`() = runBlocking {
+        // 100 'd's in a row, never EOS. maxNewTokens=5 caps the loop.
+        val log = CallLog()
+        val tokenizer = buildTinyTokenizer(eosId = 99)
+        val script = List(100) { 3 }
+        val engine = FakeEngine(
+            vocabSize = 100,
+            eosTokenId = 99,
+            promptLen = 3,
+            predictionsAfterPrefill = script,
+            log = log,
+        )
+        val sampler = LiteRTSampler(temperature = 0f, topP = 1f, topK = 0, random = Random(42))
+        val gen = LiteRTGenerator(engine, tokenizer, sampler, maxNewTokens = 5)
+
+        val output = gen.generate("abc") // tokenizes to [0,1,2]
+        assertEquals("ddddd", output)
+    }
+
+    @Test
+    fun `kvCachePosition increments monotonically across calls`() = runBlocking {
+        val log = CallLog()
+        val tokenizer = buildTinyTokenizer(eosId = 99)
+        val engine = FakeEngine(
+            vocabSize = 100,
+            eosTokenId = 99,
+            promptLen = 3,
+            predictionsAfterPrefill = listOf(3, 4, 99),
+            log = log,
+        )
+        val sampler = LiteRTSampler(temperature = 0f, topP = 1f, topK = 0, random = Random(42))
+        val gen = LiteRTGenerator(engine, tokenizer, sampler, maxNewTokens = 16)
+
+        gen.generate("abc")
+
+        // Expected calls (token, kvPos):
+        //  0: (0, 0) prefill[0] — early-prefill, argmax irrelevant
+        //  1: (1, 1) prefill[1] — early-prefill, argmax irrelevant
+        //  2: (2, 2) prefill[2] — last prefill -> sample produces 3
+        //  3: (3, 3) decode-feed -> sample produces 4
+        //  4: (4, 4) decode-feed -> sample produces 99 -> EOS halts
+        assertEquals(5, log.calls.size)
+        assertEquals(0 to 0, log.calls[0])
+        assertEquals(1 to 1, log.calls[1])
+        assertEquals(2 to 2, log.calls[2])
+        assertEquals(3 to 3, log.calls[3])
+        assertEquals(4 to 4, log.calls[4])
+        for (i in log.calls.indices) {
+            assertEquals(i, log.calls[i].second)
+        }
+    }
+
+    @Test
+    fun `empty prompt throws GenerationFailed`() = runBlocking {
+        val log = CallLog()
+        val tokenizer = buildTinyTokenizer(eosId = 99)
+        val engine = FakeEngine(
+            vocabSize = 100,
+            eosTokenId = 99,
+            promptLen = 0,
+            predictionsAfterPrefill = listOf(3),
+            log = log,
+        )
+        val sampler = LiteRTSampler(temperature = 0f, topP = 1f, topK = 0, random = Random(42))
+        val gen = LiteRTGenerator(engine, tokenizer, sampler, maxNewTokens = 4)
+
+        try {
+            gen.generate("")
+            org.junit.Assert.fail("expected GenerationFailed for empty prompt")
+        } catch (e: co.deepvoiceai.bridge.litert.core.LiteRTBackendError.GenerationFailed) {
+            assertTrue(e.message!!.contains("empty"))
+        }
+        // Engine never invoked — the generator validates BEFORE the first
+        // runStep call.
+        assertEquals(0, log.calls.size)
+    }
+}

package/android/src/test/java/co/deepvoiceai/bridge/litert/core/Internal/LiteRTSamplerTest.kt

@@ -0,0 +1,136 @@
+package co.deepvoiceai.bridge.litert.core.Internal
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import kotlin.random.Random
+
+/**
+ * Unit tests for [LiteRTSampler]. Pure-Kotlin sampler — no Robolectric or
+ * Android runtime needed, plain JUnit 4.
+ *
+ * The sampler mirrors `CoreMLSampler.swift` (iOS); these tests intentionally
+ * mirror what would be the iOS test cases so a behavioural divergence
+ * surfaces in both suites.
+ */
+class LiteRTSamplerTest {
+
+    /**
+     * temperature == 0 must take the pure-argmax path regardless of topP /
+     * topK. This is the deterministic chat / function-calling default.
+     */
+    @Test
+    fun `temperature zero is argmax`() {
+        val sampler = LiteRTSampler(temperature = 0f, topP = 1f, topK = 0, random = Random(42))
+        val logits = floatArrayOf(0.1f, 5.0f, -1.0f, 4.99f)
+        // Argmax = index 1 (5.0). Run repeatedly to confirm zero variance.
+        repeat(8) {
+            assertEquals(1, sampler.sample(logits))
+        }
+    }
+
+    /**
+     * topK = 1 must collapse to argmax even when temperature > 0 — the
+     * post-softmax distribution has a single non-zero entry, so multinomial
+     * sampling can only return the argmax index.
+     */
+    @Test
+    fun `topK one with positive temperature is deterministic argmax`() {
+        val sampler = LiteRTSampler(temperature = 1.0f, topP = 1f, topK = 1, random = Random(42))
+        val logits = floatArrayOf(-2.0f, 0.5f, 3.7f, 1.2f)
+        // Argmax = index 2.
+        repeat(16) {
+            assertEquals(2, sampler.sample(logits))
+        }
+    }
+
+    /**
+     * topP truncation: with cumulative-prob cutoff = 0.5 and a sharply
+     * peaked distribution (one logit dominates softmax > 0.5), only the
+     * argmax index can be returned.
+     */
+    @Test
+    fun `topP truncation keeps cumulative probability cutoff`() {
+        val sampler = LiteRTSampler(temperature = 1.0f, topP = 0.5f, topK = 0, random = Random(42))
+        // logits[3] = 10 dominates softmax (>>99% mass) — top-p=0.5 keeps
+        // exactly one index, so sampling collapses to argmax = 3.
+        val logits = floatArrayOf(0f, 0f, 0f, 10f, 0f)
+        repeat(16) {
+            assertEquals(3, sampler.sample(logits))
+        }
+    }
+
+    /**
+     * Without truncation and a flat distribution, different RNG seeds
+     * must select different indices — confirms the multinomial path runs
+     * (regression test against an accidental shortcut to argmax).
+     */
+    @Test
+    fun `flat distribution with different seeds yields varied samples`() {
+        val flat = FloatArray(8) { 0f } // softmax = uniform 1/8
+        val s1 = LiteRTSampler(temperature = 1f, topP = 1f, topK = 0, random = Random(1))
+        val s2 = LiteRTSampler(temperature = 1f, topP = 1f, topK = 0, random = Random(99))
+        // Two seeds drawing from a uniform distribution over 8 buckets are
+        // overwhelmingly likely to disagree on at least one of 5 draws —
+        // probability of all 5 matches is (1/8)^5 ~ 3e-5.
+        var anyDifferent = false
+        repeat(5) {
+            if (s1.sample(flat) != s2.sample(flat)) {
+                anyDifferent = true
+            }
+        }
+        assertTrue("expected varied samples across different seeds", anyDifferent)
+    }
+
+    /**
+     * Determinism: same seed + same logits must produce the same sequence
+     * of samples. Catches accidental statics or non-deterministic sort.
+     */
+    @Test
+    fun `same seed produces identical sequence`() {
+        val logits = floatArrayOf(1f, 2f, 3f, 4f, 5f)
+        val s1 = LiteRTSampler(temperature = 0.7f, topP = 0.9f, topK = 4, random = Random(42))
+        val s2 = LiteRTSampler(temperature = 0.7f, topP = 0.9f, topK = 4, random = Random(42))
+        for (i in 0 until 32) {
+            val a = s1.sample(logits)
+            val b = s2.sample(logits)
+            assertEquals("sample $i", a, b)
+        }
+    }
+
+    /**
+     * Single-element logits: every sampler config must return index 0
+     * since there's nothing else to pick. Edge case at the start of the
+     * vocab loop.
+     */
+    @Test
+    fun `single element logits returns index zero`() {
+        val logits = floatArrayOf(2.0f)
+        val configs = listOf(
+            LiteRTSampler(temperature = 0f, topP = 1f, topK = 0, random = Random(42)),
+            LiteRTSampler(temperature = 1f, topP = 1f, topK = 0, random = Random(42)),
+            LiteRTSampler(temperature = 1f, topP = 0.5f, topK = 1, random = Random(42)),
+        )
+        for (s in configs) {
+            assertEquals(0, s.sample(logits))
+        }
+    }
+
+    /**
+     * Soft sanity: with a non-degenerate distribution and temperature > 0,
+     * a sufficiently large sample should NOT always equal the argmax.
+     * Ensures the sampler isn't silently short-circuiting to argmax.
+     */
+    @Test
+    fun `non greedy sampling is not always argmax`() {
+        val logits = floatArrayOf(1f, 1.05f, 1f, 1f) // near-uniform with slight tilt
+        val sampler = LiteRTSampler(temperature = 1f, topP = 1f, topK = 0, random = Random(7))
+        var nonArgmax = 0
+        for (i in 0 until 50) {
+            val s = sampler.sample(logits)
+            if (s != 1) nonArgmax += 1 // 1 is the argmax
+        }
+        assertNotEquals("expected at least some non-argmax draws", 0, nonArgmax)
+    }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@dvai-bridge/android-litert-core",
+  "version": "4.0.0",
+  "description": "DVAI-Bridge Android LiteRT core — wraps Google's LiteRT (TFLite) runtime with HuggingFace tokenizers, exposes the OpenAI-compatible HTTP surface via android-shared-core. Capacitor-free.",
+  "author": "Deep Chakraborty <https://github.com/dk013>",
+  "license": "Custom (See LICENSE)",
+  "files": [
+    "android/src",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/settings.gradle",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}