@dvai-bridge/android 4.0.0

package/LICENSE

@@ -0,0 +1,51 @@
+# Deep Voice Ai Limited - Software License Agreement
+
+**Version 1.0.0**
+
+This License Agreement governs the use of the DVAI-Bridge software (the "Software"). By downloading, installing, or using the Software, you agree to be bound by the terms of this License.
+
+---
+
+## 1. LICENSE GRANTS
+
+### 1.1 Development and Personal Use (Free Tier)
+Deep Voice Ai Limited ("Licensor") grants you a non-exclusive, non-transferable, royalty-free license to use the Software solely for:
+- Internal development and testing purposes.
+- Non-commercial personal projects.
+- Academic and non-profit research.
+
+### 1.2 Commercial Use (Paid Tier)
+Any use of the Software for **Commercial Purposes** requires a separate, paid Commercial License from Licensor. "Commercial Purposes" include:
+- Use in production environments.
+- Integration into revenue-generating products or services.
+- Distribution to third-party customers for a fee.
+- Use by an entity with more than $100,000 USD in annual revenue.
+
+To obtain a Commercial License, contact `info@deepvoiceai.co` or visit `https://deepvoiceai.co/licensing`.
+
+---
+
+## 2. RESTRICTIONS
+Except as expressly permitted, you may not:
+- Sublicense, rent, lease, or resell the Software without express permission.
+- Remove any proprietary notices or branding from the Software.
+- Use the Software for any illegal or malicious purposes.
+
+---
+
+## 3. INTELLECTUAL PROPERTY
+The Software is owned by **Deep Voice Ai Limited** and is protected by copyright and intellectual property laws. This agreement does not transfer ownership of the Software.
+
+---
+
+## 4. NO WARRANTY
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE.
+
+---
+
+## 5. GOVERNING LAW
+This License shall be governed by and construed in accordance with the laws of the jurisdiction where Deep Voice Ai Limited is registered.
+
+---
+
+© 2026 Deep Voice Ai Limited. All rights reserved.

package/README.md

@@ -0,0 +1,199 @@
+![DVAI-Bridge](/assets/banner.png)
+
+# DVAI-Bridge
+
+<!-- [![Smoke — real models](https://github.com/Westenets/dvai-bridge/actions/workflows/smoke-real-models.yml/badge.svg?branch=main)](https://github.com/Westenets/dvai-bridge/actions/workflows/smoke-real-models.yml) -->
+
+[![License](https://img.shields.io/badge/License-Commercial-blue.svg)](LICENSE) ![Node.js](https://img.shields.io/badge/Node.js-22+-green?logo=node.js) ![TypeScript](https://img.shields.io/badge/TypeScript-5.6+-blue?logo=typescript) ![Swift](https://img.shields.io/badge/Swift-5.9+-F05138?logo=swift) ![Kotlin](https://img.shields.io/badge/Kotlin-2.0+-7F52FF?logo=kotlin) ![Flutter](https://img.shields.io/badge/Flutter-3.39+-02569B?logo=flutter) ![.NET](https://img.shields.io/badge/.NET-10.0_LTS-512BD4?logo=dotnet)
+
+> **The local OpenAI server you embed inside your app.**
+> One library. One HTTP wire. Every platform. Zero install for your users.
+
+**Docs:** [dvai-bridge.deepvoiceai.co](https://dvai-bridge.deepvoiceai.co)
+
+```ts
+import { DVAI } from "@dvai-bridge/core";
+import OpenAI from "openai";
+
+const dvai = new DVAI({ backend: "transformers" });
+await dvai.initialize();
+
+const openai = new OpenAI({ baseURL: dvai.baseUrl, apiKey: "ignored" });
+await openai.chat.completions.create({
+  model: dvai.transformersModelId,
+  messages: [{ role: "user", content: "Hello!" }],
+});
+```
+
+That's it. A real OpenAI-compatible server is now running inside your app's
+own process. Point any OpenAI client — LangChain, the OpenAI SDK, the Vercel
+AI SDK, anything — at `dvai.baseUrl` and your agent code keeps working.
+
+Built by **[Deep Voice AI](https://deepvoiceai.co)**.
+
+---
+
+## Why it exists
+
+Local AI works beautifully on a laptop with **Ollama + LangChain**. Then you
+try to ship the app and your users don't have Ollama. Mobile can't run it.
+Corporate IT won't add another daemon. So you reinvent the same plumbing —
+spawn an inference engine, bind a port, translate to OpenAI HTTP, handle
+CORS, manage lifecycle, wrap the accelerator of the day per platform — and
+do it all over again for every target OS.
+
+DVAI-Bridge is that plumbing, packaged as a library, for every client
+platform.
+
+---
+
+## What you get
+
+- **One OpenAI HTTP surface.** Bound on `127.0.0.1` (or `0.0.0.0` for
+  device-to-device). Streaming, embeddings, models, recovery — all built in.
+- **Six SDKs.** `@dvai-bridge/core` + `react` + `vanilla` + `capacitor`,
+  `DVAIBridge` (Swift / iOS), `co.deepvoiceai:dvai-bridge` (Kotlin / Android),
+  `@dvai-bridge/react-native`, `dvai_bridge` (Flutter), `co.deepvoiceai.dvai-bridge` (.NET).
+- **Nine backends.** WebLLM, Transformers.js, llama.cpp, Apple Foundation
+  Models, MLX, CoreML / ANE, MediaPipe LLM, LiteRT, ONNX Runtime GenAI —
+  selected per-platform, invisible to your agent code.
+- **Native acceleration** wherever it runs: WebGPU in browsers, CUDA / Metal
+  / Vulkan / DirectML on desktop, ANE / Metal / MLX on iOS, NNAPI / QNN
+  Hexagon / GPU delegate on Android.
+- **Multimodal.** Text, image, audio, video — declarative loader for
+  cutting-edge models (Gemma 4, LLaVA, Idefics) without waiting for library
+  updates.
+- **Distributed inference (v3.0+).** Phone too slow? Offload to your laptop
+  on the same Wi-Fi via mDNS pairing — same OpenAI wire, transparent to
+  your code. Internet path via a self-hostable rendezvous server.
+- **DVAI Hub (v3.1+).** A first-party desktop utility that turns any device
+  into a strong-peer for the rest of your fleet. Brand-neutral install via
+  Homebrew / winget / GitHub Releases, OR fork it for your own branded
+  companion. Routes through Ollama / LM Studio / vLLM / llama-server /
+  llamafile if you've already got those running.
+- **Zero user install.** It's a library, not a daemon. `npm install`,
+  `cocoapods`, gradle — your CI already has the muscle for it.
+
+---
+
+## Supported platforms
+
+| Stack | Package | Backends |
+| --- | --- | --- |
+| Browser (React, Vue, Svelte, vanilla JS) | `@dvai-bridge/core` + `react` / `vanilla` | WebLLM (WebGPU), Transformers.js (WebGPU / WASM SIMD) |
+| Node / Bun / Electron | `@dvai-bridge/core` | Transformers.js, native llama.cpp |
+| Capacitor hybrid mobile | `@dvai-bridge/capacitor` + backend slice | Native llama.cpp (Metal iOS, Vulkan / CPU Android) |
+| iOS native (Swift) | `DVAIBridge` (SPM / CocoaPods) | llama.cpp (Metal), CoreML / ANE, Apple Foundation Models, MLX |
+| Android native (Kotlin / Java) | `co.deepvoiceai:dvai-bridge` (AAR) | llama.cpp, MediaPipe LLM, LiteRT, NNAPI / QNN |
+| React Native (≥0.77, TurboModule) | `@dvai-bridge/react-native` | All iOS + Android backends (delegates) |
+| Flutter (≥3.39) | `dvai_bridge` (pub.dev) | All iOS + Android backends (Pigeon channels) |
+| .NET 10 LTS (MAUI / Avalonia / WinUI / Catalyst / desktop) | `co.deepvoiceai.dvai-bridge*` (NuGet) | iOS / Android delegate to native; desktop = llama.cpp + ONNX Runtime GenAI + ML.NET |
+
+Full quickstart per platform: [dvai-bridge.deepvoiceai.co/guide/getting-started](https://dvai-bridge.deepvoiceai.co/guide/getting-started)
+
+---
+
+## Examples
+
+```ts
+// React
+import { DVAIProvider, useDVAI } from "@dvai-bridge/react";
+<DVAIProvider config={{ backend: "transformers" }}>
+  <Chat />
+</DVAIProvider>;
+function Chat() {
+  const { isReady, baseUrl } = useDVAI();
+  return isReady ? <div>Local AI live at {baseUrl}</div> : <Loading />;
+}
+```
+
+```swift
+// iOS
+let server = try await DVAIBridge.shared.start()
+// server.baseUrl = "http://127.0.0.1:38883/v1"
+```
+
+```kotlin
+// Android
+val server = DVAIBridge.start(context)
+// server.baseUrl = "http://127.0.0.1:38883/v1"
+```
+
+```dart
+// Flutter
+final state = await DVAIBridge.instance.start(
+  backend: BackendKind.auto,
+  modelPath: '/path/to/model.gguf',
+);
+// state.baseUrl = "http://127.0.0.1:38883/v1"
+```
+
+```csharp
+// .NET
+var server = await DVAIBridge.Shared.StartAsync(new StartOptions {
+    Backend = BackendKind.Auto,
+    ModelPath = "/path/to/model.gguf",
+});
+// server.BaseUrl = "http://127.0.0.1:38883/v1"
+```
+
+Multimodal, streaming, embeddings, distributed offload, the Hub —
+everything's at the [docs site](https://dvai-bridge.deepvoiceai.co).
+
+---
+
+## What's new in v3.1
+
+- **DVAI Hub** — Tauri desktop utility that's the strong-peer side of v3
+  distributed inference. `brew install deepvoiceai/dvai-hub/dvai-hub` (or
+  `winget install DeepVoiceAI.DVAIHub`) → mobile apps on the same Wi-Fi
+  pair with it and offload heavy inference. [Guide →](https://dvai-bridge.deepvoiceai.co/guide/dvai-hub)
+- **External-engine bridge.** Hub surfaces Ollama / LM Studio / vLLM /
+  llama-server / llamafile as additional backend pools so paired apps
+  serve from whatever's already cached. Opt-in per engine.
+- **Strict substitution policy.** Models with mismatched family / version /
+  size / type are refused by default; quant-only mismatches gated behind a
+  per-pairing `preferBetterQuant` flag. No silent mis-routing.
+- **HMAC-signed identity** on `/v1/chat/completions`. Per-app audit logs
+  surface who served what, with structured `(appId, peerDeviceId,
+  engine, requestedModel, servedModel, outcome)` rows.
+- **Library finalization.** `httpBindHost` (LAN bind), `chatCompletionInterceptor`
+  (extension point), HMAC primitives re-exported, `/v1/dvai/*` routes
+  actually dispatched, TransformersBackend Node-mode device fix.
+  [Migration v3.0 → v3.1 →](https://dvai-bridge.deepvoiceai.co/migration/v3.0-to-v3.1)
+
+---
+
+## Robustness
+
+Streaming-correct (SSE passthrough + blank-chunk detection), generation
+timeout, automatic engine-state recovery on fatal errors, port fallback,
+worker offloading, Private Network Access ready, CORS configured. The
+boring substrate so your agent code never has to think about it.
+
+---
+
+## Licensing
+
+Dual: **free for development & personal use** on `localhost` (verified at
+runtime). **Commercial use** requires a license key — `info@deepvoiceai.co`.
+
+---
+
+## Contributing
+
+PRs welcome.
+
+```bash
+pnpm install
+pnpm build
+bash scripts/build-all.sh   # full matrix (auto-skips per-host)
+```
+
+[`CONTRIBUTING.md`](./CONTRIBUTING.md) for the PR flow. Per-platform
+contributor docs (iOS / Android / RN / Flutter / .NET) under
+[`docs/development/`](./docs/development/).
+
+---
+
+© Deep Voice AI Limited. All rights reserved.

package/android/build.gradle

@@ -0,0 +1,165 @@
+// Phase 3D umbrella module — co.deepvoiceai:dvai-bridge AAR.
+//
+// Depends on the four Android cores (shared / llama / mediapipe / litert)
+// via Maven coordinates (mavenLocal in dev, GitHub Packages in prod). The
+// public DVAIBridge Kotlin object wires those backends behind a single
+// 8-method API surface that mirrors the iOS DVAIBridge SDK.
+
+buildscript {
+    ext {
+        kotlinVersion = '2.3.21'
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:9.2.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    }
+}
+
+ext {
+    junitVersion = '4.13.2'
+    androidxAppCompatVersion = '1.7.1'
+    coroutinesVersion = '1.10.2'
+    ktorVersion = '2.3.13'
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+        // Phase 3D: cores resolve here in dev (after `bash scripts/android-publish-local.sh`).
+        // Production publishes resolve from GitHub Packages.
+        mavenLocal()
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
+
+android {
+    namespace 'co.deepvoiceai.bridge'
+    // Phase 2 Task 3 (examples) library fix: see shared-core/android/build.gradle
+    // for the rationale — `-PcompileSdkOverride=35` lets Windows hosts sidestep
+    // an AGP 9.2.0 parseLocalResources bug against android-36's public-final.xml.
+    compileSdk(project.findProperty('compileSdkOverride')?.toInteger() ?: 36)
+
+    defaultConfig {
+        minSdk 24
+        targetSdk(project.findProperty('compileSdkOverride')?.toInteger() ?: 36)
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+        // Phase 3D Task 17: integration tests read SMOKE_* env vars via
+        // BuildConfig fields. Empty defaults make the tests self-skip via
+        // `Assume.assumeFalse(... isEmpty())` when the env vars aren't set.
+        // CI workflows export the env vars from repo secrets; local dev
+        // can `export SMOKE_MODEL_URL=... && ./gradlew connectedAndroidTest`.
+        buildConfigField "String", "SMOKE_MODEL_URL",
+                "\"${System.getenv('SMOKE_MODEL_URL') ?: ''}\""
+        buildConfigField "String", "SMOKE_MODEL_SHA256",
+                "\"${System.getenv('SMOKE_MODEL_SHA256') ?: ''}\""
+        buildConfigField "String", "SMOKE_MEDIAPIPE_MODEL_URL",
+                "\"${System.getenv('SMOKE_MEDIAPIPE_MODEL_URL') ?: ''}\""
+        buildConfigField "String", "SMOKE_MEDIAPIPE_MODEL_SHA256",
+                "\"${System.getenv('SMOKE_MEDIAPIPE_MODEL_SHA256') ?: ''}\""
+        buildConfigField "String", "SMOKE_LITERT_MODEL_URL",
+                "\"${System.getenv('SMOKE_LITERT_MODEL_URL') ?: ''}\""
+        buildConfigField "String", "SMOKE_LITERT_MODEL_SHA256",
+                "\"${System.getenv('SMOKE_LITERT_MODEL_SHA256') ?: ''}\""
+        buildConfigField "String", "SMOKE_LITERT_TOKENIZER_URL",
+                "\"${System.getenv('SMOKE_LITERT_TOKENIZER_URL') ?: ''}\""
+    }
+
+    buildFeatures {
+        buildConfig = true
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    testOptions {
+        unitTests.includeAndroidResources = true
+    }
+
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+        }
+    }
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    }
+}
+
+dependencies {
+    // Cores — each declared as `api` so consumer apps that pull just the
+    // umbrella see the underlying types (BackendKind, HandlerContext, etc.)
+    // without re-declaring the deps.
+    api "co.deepvoiceai:android-shared-core:$dvaiBridgeVersion"
+    api "co.deepvoiceai:android-llama-core:$dvaiBridgeVersion"
+    api "co.deepvoiceai:android-mediapipe-core:$dvaiBridgeVersion"
+    api "co.deepvoiceai:android-litert-core:$dvaiBridgeVersion"
+
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutinesVersion"
+    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.11.0'
+
+    // v3.3 — offline JWT license validator. nimbus-jose-jwt is the
+    // widely-vetted JOSE implementation for the JVM; we use ES256 only
+    // (refuse alg=none / HS256, classic algorithm-confusion defense).
+    // See android/src/main/java/co/deepvoiceai/bridge/license/.
+    implementation 'com.nimbusds:nimbus-jose-jwt:10.5'
+
+    // Phase 5 (v3.2) — outgoing-offload pre-routing proxy. The proxy
+    // binds the public port; the underlying native backend binds an
+    // internal loopback port. Per-request the proxy decides local-vs-
+    // forward and either streams from local or HMAC-signs + forwards
+    // to a paired peer. CIO engine is the smallest of the Ktor engine
+    // options (~500 KB AAR contribution vs Netty's ~3 MB).
+    implementation "io.ktor:ktor-server-core:$ktorVersion"
+    implementation "io.ktor:ktor-server-cio:$ktorVersion"
+    implementation "io.ktor:ktor-server-status-pages:$ktorVersion"
+    implementation "io.ktor:ktor-client-core:$ktorVersion"
+    implementation "io.ktor:ktor-client-cio:$ktorVersion"
+
+    testImplementation "junit:junit:$junitVersion"
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutinesVersion"
+    testImplementation 'org.robolectric:robolectric:4.16.1'
+    testImplementation "io.ktor:ktor-server-test-host:$ktorVersion"
+    testImplementation 'com.squareup.okhttp3:mockwebserver:5.3.2'
+
+    androidTestImplementation 'androidx.test:runner:1.7.0'
+    androidTestImplementation 'androidx.test.ext:junit:1.3.0'
+    androidTestImplementation 'com.squareup.okhttp3:okhttp:5.3.2'
+}
+
+// Phase 3D Task 4: copy-paste publishing block (see llama-core for the
+// rationale on why each Gradle root has its own copy).
+afterEvaluate {
+    publishing {
+        publications {
+            release(MavenPublication) {
+                groupId = 'co.deepvoiceai'
+                artifactId = 'dvai-bridge'
+                version = (project.findProperty('dvaiBridgeVersion') ?: '4.0.0').toString()
+                from components.release
+            }
+        }
+        repositories {
+            maven {
+                name = 'GitHubPackages'
+                url = uri('https://maven.pkg.github.com/dvai-global/dvai-bridge')
+                credentials {
+                    username = project.findProperty('gpr.user') ?: System.getenv('GITHUB_ACTOR')
+                    password = project.findProperty('gpr.key') ?: System.getenv('GITHUB_TOKEN')
+                }
+            }
+        }
+    }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true
+org.gradle.jvmargs=-Xmx4096m
+dvaiBridgeVersion=4.0.0

package/android/settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'dvai-bridge-android'

package/android/src/androidTest/java/co/deepvoiceai/bridge/RealModelIntegrationTest.kt

@@ -0,0 +1,162 @@
+package co.deepvoiceai.bridge
+
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assume.assumeFalse
+import org.junit.Test
+import org.junit.runner.RunWith
+import kotlinx.coroutines.runBlocking
+import java.io.File
+import java.security.MessageDigest
+
+/**
+ * End-to-end integration tests for the Android Native SDK against real models.
+ * Each backend has its own test method; each skips cleanly when its
+ * prereqs aren't met (env vars / BuildConfig fields missing).
+ *
+ * Mirrors the iOS `RealModelIntegrationTest.swift` pattern.
+ *
+ * Set env vars on the host (read by Gradle into BuildConfig via Task 17's
+ * `buildConfigField` injection):
+ *   - SMOKE_MODEL_URL + SMOKE_MODEL_SHA256        (Llama)
+ *   - SMOKE_MEDIAPIPE_MODEL_URL + SMOKE_MEDIAPIPE_MODEL_SHA256
+ *   - SMOKE_LITERT_MODEL_URL + SMOKE_LITERT_MODEL_SHA256 + SMOKE_LITERT_TOKENIZER_URL
+ *
+ * Run: `./gradlew :dvai-bridge-android:connectedAndroidTest` against a
+ * connected device or emulator.
+ */
+@RunWith(AndroidJUnit4::class)
+class RealModelIntegrationTest {
+    private val context get() = InstrumentationRegistry.getInstrumentation().targetContext
+    private val httpClient = OkHttpClient()
+
+    @After
+    fun tearDown() = runBlocking {
+        runCatching { DVAIBridge.stop() }
+    }
+
+    @Test
+    fun llamaBackendIntegration() = runBlocking {
+        val url = BuildConfig.SMOKE_MODEL_URL
+        val sha = BuildConfig.SMOKE_MODEL_SHA256
+        assumeFalse("SMOKE_MODEL_URL not set", url.isEmpty())
+        assumeFalse("SMOKE_MODEL_SHA256 not set", sha.isEmpty())
+
+        DVAIBridge.init(context)
+        val download = DVAIBridge.downloadModel(
+            DownloadOptions(url = url, sha256 = sha, destFilename = "int-llama.gguf"),
+        )
+
+        val server = DVAIBridge.start(StartOptions(
+            backend = BackendKind.Llama,
+            modelPath = download.path,
+            // GPU offload off by default on emulator (no Vulkan).
+            gpuLayers = 0,
+            contextSize = 1024,
+        ))
+        assertEquals(BackendKind.Llama, server.backend)
+
+        val response = postChatCompletion(server.baseUrl, "What is 2+2?")
+        assertFalse("llama completion should not be empty", response.isEmpty())
+    }
+
+    @Test
+    fun mediaPipeBackendIntegration() = runBlocking {
+        val url = BuildConfig.SMOKE_MEDIAPIPE_MODEL_URL
+        val sha = BuildConfig.SMOKE_MEDIAPIPE_MODEL_SHA256
+        assumeFalse("SMOKE_MEDIAPIPE_MODEL_URL not set", url.isEmpty())
+        assumeFalse("SMOKE_MEDIAPIPE_MODEL_SHA256 not set", sha.isEmpty())
+
+        DVAIBridge.init(context)
+        val download = DVAIBridge.downloadModel(
+            DownloadOptions(url = url, sha256 = sha, destFilename = "int-mediapipe.task"),
+        )
+
+        val server = DVAIBridge.start(StartOptions(
+            backend = BackendKind.MediaPipe,
+            modelPath = download.path,
+        ))
+        assertEquals(BackendKind.MediaPipe, server.backend)
+
+        val response = postChatCompletion(server.baseUrl, "Hello")
+        assertFalse("mediapipe completion should not be empty", response.isEmpty())
+    }
+
+    @Test
+    fun liteRTBackendIntegration() = runBlocking {
+        val modelUrl = BuildConfig.SMOKE_LITERT_MODEL_URL
+        val modelSha = BuildConfig.SMOKE_LITERT_MODEL_SHA256
+        val tokUrl = BuildConfig.SMOKE_LITERT_TOKENIZER_URL
+        assumeFalse("SMOKE_LITERT_MODEL_URL not set", modelUrl.isEmpty())
+        assumeFalse("SMOKE_LITERT_MODEL_SHA256 not set", modelSha.isEmpty())
+        assumeFalse("SMOKE_LITERT_TOKENIZER_URL not set", tokUrl.isEmpty())
+
+        DVAIBridge.init(context)
+        val modelDownload = DVAIBridge.downloadModel(
+            DownloadOptions(url = modelUrl, sha256 = modelSha, destFilename = "int-litert.tflite"),
+        )
+        // tokenizer.json: download into the same cache dir, no sha required (small file).
+        val tokDir = File(modelDownload.path).parentFile ?: error("download path has no parent")
+        val tokFile = File(tokDir, "tokenizer.json")
+        downloadRaw(tokUrl, tokFile)
+
+        val server = DVAIBridge.start(StartOptions(
+            backend = BackendKind.LiteRT,
+            modelPath = modelDownload.path,
+            tokenizerPath = tokDir.absolutePath,
+            maxNewTokens = 32,
+        ))
+        assertEquals(BackendKind.LiteRT, server.backend)
+
+        val response = postChatCompletion(server.baseUrl, "What is 2+2?")
+        assertFalse("litert completion should not be empty", response.isEmpty())
+    }
+
+    private fun postChatCompletion(baseUrl: String, userMessage: String): String {
+        val body = JSONObject().apply {
+            put("messages", JSONArray().apply {
+                put(JSONObject().apply {
+                    put("role", "user")
+                    put("content", userMessage)
+                })
+            })
+            put("max_tokens", 32)
+            put("temperature", 0.0)
+        }.toString()
+        val req = Request.Builder()
+            .url("$baseUrl/chat/completions")
+            .post(body.toRequestBody("application/json".toMediaType()))
+            .build()
+        httpClient.newCall(req).execute().use { resp ->
+            val text = resp.body?.string() ?: ""
+            assertNotNull("response body", text)
+            if (resp.code != 200) error("POST failed: ${resp.code} $text")
+            val json = JSONObject(text)
+            val choices = json.optJSONArray("choices") ?: return ""
+            if (choices.length() == 0) return ""
+            val message = choices.getJSONObject(0).optJSONObject("message") ?: return ""
+            return message.optString("content", "")
+        }
+    }
+
+    private fun downloadRaw(url: String, dest: File) {
+        val req = Request.Builder().url(url).build()
+        httpClient.newCall(req).execute().use { resp ->
+            if (resp.code != 200) error("downloadRaw($url) -> ${resp.code}")
+            dest.outputStream().use { out -> resp.body!!.byteStream().copyTo(out) }
+        }
+    }
+
+    private fun assertEquals(expected: BackendKind, actual: BackendKind) {
+        if (expected != actual) error("expected $expected, got $actual")
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/co/deepvoiceai/bridge/BackendKind.kt

@@ -0,0 +1,21 @@
+package co.deepvoiceai.bridge
+
+/**
+ * Inference backend selector. Mirrors the iOS DVAIBridge `BackendKind`
+ * enum 1:1 in name and case order so cross-platform consumers can
+ * reason about them identically.
+ *
+ * - [Auto]:      Pick the best backend for the supplied options at
+ *                runtime. See [BackendSelector] for the resolution rules.
+ * - [Llama]:     llama.cpp via android-llama-core. Universal `.gguf` support.
+ * - [MediaPipe]: Google's MediaPipe LLM Inference (LiteRT-LM under the hood
+ *                post-Phase 3B). Consumes `.task` checkpoints.
+ * - [LiteRT]:    Bare LiteRT (TFLite successor) for `.tflite` / `.litertlm`
+ *                Llama-style stateful checkpoints — Phase 3D's new backend.
+ */
+enum class BackendKind {
+    Auto,
+    Llama,
+    MediaPipe,
+    LiteRT,
+}

package/android/src/main/java/co/deepvoiceai/bridge/BackendSelector.kt

@@ -0,0 +1,28 @@
+package co.deepvoiceai.bridge
+
+import java.io.File
+
+/**
+ * Auto-resolution rules for [BackendKind.Auto]. Pure function, no Android
+ * runtime dependency — testable as a JVM unit test.
+ *
+ * The order below is the resolution priority. First matching rule wins:
+ *   1. modelPath ends with `.task` and the file exists -> MediaPipe.
+ *   2. modelPath ends with `.tflite` or `.litertlm`    -> LiteRT.
+ *   3. Default (incl. .gguf and any unknown extension) -> Llama.
+ *
+ * Mirrors the iOS DVAIBridge BackendSelector logic (see
+ * `packages/dvai-bridge-ios/ios/Sources/DVAIBridge/BackendSelector.swift`)
+ * — keep them in lockstep when adding new dispatch heuristics.
+ */
+object BackendSelector {
+    fun resolve(opts: StartOptions): BackendKind {
+        if (opts.backend != BackendKind.Auto) return opts.backend
+        val path = opts.modelPath
+        if (path != null) {
+            if (path.endsWith(".task") && File(path).exists()) return BackendKind.MediaPipe
+            if (path.endsWith(".tflite") || path.endsWith(".litertlm")) return BackendKind.LiteRT
+        }
+        return BackendKind.Llama
+    }
+}