@dvai-bridge/android-shared-core 4.0.0

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/capability/Precheck.kt

@@ -0,0 +1,180 @@
+package co.deepvoiceai.bridge.shared.core.capability
+
+import android.app.ActivityManager
+import android.content.Context
+import android.os.Build
+import kotlinx.serialization.Serializable
+
+/**
+ * v3.2 — pre-init capability gate for the Android SDK.
+ *
+ * Mirrors the TypeScript core's `assessCapability()` in
+ * `@dvai-bridge/core/src/capability/precheck.ts`. The rule:
+ *
+ * Before any model download or backend init:
+ *   - if estimated tok/s < hardwareMinimum (default 3) → mode=TOO_WEAK
+ *     (host shows a system popup, SDK throws HardwareTooWeak; no
+ *      model download happens).
+ *   - else if estimated tok/s < minLocalCapability (default 10) →
+ *     mode=OFFLOAD_ONLY (skip model load entirely; bring up only the
+ *     proxy + discovery + pairing).
+ *   - else → mode=OK (load locally + proxy + discovery).
+ *
+ * Heuristic-only — no model is loaded at this stage. A real probe
+ * refines the estimate AFTER a model is loaded and a request has
+ * actually run; that path is unchanged from v3.0.
+ */
+object CapabilityPrecheck {
+
+    /** Result of [assess]. */
+    @Serializable
+    data class Result(
+        val mode: PrecheckMode,
+        /** Estimated decode tok/s on this device for any 1–3B model. */
+        val tokPerSec: Double,
+        val hints: DeviceCapabilityHints,
+        /** Human-readable explanation; safe to log + display in UI. */
+        val reason: String,
+    )
+
+    /** Tunable thresholds. */
+    data class Thresholds(
+        /** Below this, the device is too weak to run inference at all.
+         *  Default 3.0 tok/s — anything below feels broken for chat. */
+        val hardwareMinimum: Double = 3.0,
+        /** Below this, run in offload-only mode. Default 10.0. */
+        val minLocalCapability: Double = 10.0,
+    )
+
+    /** Run the precheck. [hints] override is for tests. */
+    fun assess(
+        context: Context,
+        thresholds: Thresholds = Thresholds(),
+        hints: DeviceCapabilityHints? = null,
+    ): Result {
+        val resolvedHints = hints ?: detectDeviceHints(context)
+        val tokPerSec = heuristicTokPerSec(resolvedHints)
+
+        return when {
+            tokPerSec < thresholds.hardwareMinimum -> Result(
+                mode = PrecheckMode.TOO_WEAK,
+                tokPerSec = tokPerSec,
+                hints = resolvedHints,
+                reason = "estimated $tokPerSec tok/s, below the " +
+                        "${thresholds.hardwareMinimum} tok/s hardware floor — " +
+                        "local inference would be unusable.",
+            )
+
+            tokPerSec < thresholds.minLocalCapability -> Result(
+                mode = PrecheckMode.OFFLOAD_ONLY,
+                tokPerSec = tokPerSec,
+                hints = resolvedHints,
+                reason = "estimated $tokPerSec tok/s, below the " +
+                        "${thresholds.minLocalCapability} tok/s comfort threshold — " +
+                        "model will not be loaded locally; every request will be " +
+                        "forwarded to a paired peer.",
+            )
+
+            else -> Result(
+                mode = PrecheckMode.OK,
+                tokPerSec = tokPerSec,
+                hints = resolvedHints,
+                reason = "estimated $tokPerSec tok/s, above the " +
+                        "${thresholds.minLocalCapability} tok/s threshold — running normally.",
+            )
+        }
+    }
+
+    /** Pure heuristic — no Context needed; mirrors TS heuristicTokPerSec. */
+    fun heuristicTokPerSec(hints: DeviceCapabilityHints): Double {
+        // Base score by GPU class — observed floors for 1–3B q4 GGUFs.
+        val gpuBase = when (hints.gpuClass) {
+            GpuClass.NONE -> 3.0
+            GpuClass.INTEGRATED -> 8.0
+            GpuClass.DISCRETE -> 35.0
+            GpuClass.APPLE_SILICON -> 40.0   // unused on Android but kept for parity
+        }
+
+        val cpuMul = when (hints.cpuClass) {
+            CpuClass.LOW -> 0.6
+            CpuClass.MID -> 1.0
+            CpuClass.HIGH -> 1.3
+        }
+
+        val ramMul = when {
+            hints.ramGb < 4 -> 0.3
+            hints.ramGb < 8 -> 0.7
+            else -> 1.0
+        }
+
+        val npuBonus = if (hints.hasNpu) 1.4 else 1.0
+
+        val raw = gpuBase * cpuMul * ramMul * npuBonus
+        return Math.round(raw * 10) / 10.0
+    }
+
+    /** Best-effort introspection from ActivityManager + Build properties. */
+    fun detectDeviceHints(context: Context): DeviceCapabilityHints {
+        val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        val memInfo = ActivityManager.MemoryInfo()
+        am.getMemoryInfo(memInfo)
+        val ramGb = (memInfo.totalMem.toDouble() / (1024L * 1024 * 1024)).toInt()
+
+        val cores = Runtime.getRuntime().availableProcessors()
+        val cpuClass = when {
+            cores >= 8 -> CpuClass.HIGH
+            cores >= 4 -> CpuClass.MID
+            else -> CpuClass.LOW
+        }
+
+        // Android phones don't have discrete GPUs — most have an integrated
+        // mobile GPU (Adreno / Mali / PowerVR). Treat as INTEGRATED unless
+        // the device is so old it doesn't even have one (rare in 2026+).
+        val gpuClass = GpuClass.INTEGRATED
+
+        // NPU detection: Pixel + Samsung + recent Qualcomm flagship phones
+        // have NPUs (Tensor / Hexagon / etc.). Best signal we have without
+        // a runtime probe is hardware/model name, but those strings are
+        // unreliable across regions. Default false; the model-load probe
+        // refines after first run.
+        val hasNpu = false
+
+        return DeviceCapabilityHints(
+            hasNpu = hasNpu,
+            ramGb = ramGb,
+            gpuClass = gpuClass,
+            cpuClass = cpuClass,
+        )
+    }
+}
+
+/** Parallels the TS `DeviceCapabilityHints` interface. */
+@Serializable
+data class DeviceCapabilityHints(
+    val hasNpu: Boolean,
+    val ramGb: Int,
+    val gpuClass: GpuClass,
+    val cpuClass: CpuClass,
+)
+
+@Serializable
+enum class GpuClass {
+    @kotlinx.serialization.SerialName("none") NONE,
+    @kotlinx.serialization.SerialName("integrated") INTEGRATED,
+    @kotlinx.serialization.SerialName("discrete") DISCRETE,
+    @kotlinx.serialization.SerialName("apple-silicon") APPLE_SILICON,
+}
+
+@Serializable
+enum class CpuClass {
+    @kotlinx.serialization.SerialName("low") LOW,
+    @kotlinx.serialization.SerialName("mid") MID,
+    @kotlinx.serialization.SerialName("high") HIGH,
+}
+
+@Serializable
+enum class PrecheckMode {
+    OK,
+    OFFLOAD_ONLY,
+    TOO_WEAK,
+}

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/discovery/NsdAdvertiser.kt

@@ -0,0 +1,86 @@
+package co.deepvoiceai.bridge.shared.core.discovery
+
+import android.content.Context
+import android.net.nsd.NsdManager
+import android.net.nsd.NsdServiceInfo
+import android.util.Log
+
+/**
+ * Advertises THIS device on the LAN as a `_dvai-bridge._tcp` mDNS
+ * service via Android's [NsdManager.registerService]. Pairs with
+ * [NsdDiscovery] running on peers.
+ *
+ * The TXT record exposes: deviceId, deviceName, dvaiVersion, models,
+ * capability — see [PeerTxtKeys].
+ */
+class NsdAdvertiser(
+    private val context: Context,
+) {
+    companion object {
+        private const val TAG = "DvaiNsdAdvertiser"
+    }
+
+    private val nsdManager: NsdManager =
+        context.applicationContext.getSystemService(Context.NSD_SERVICE) as NsdManager
+
+    @Volatile private var listener: NsdManager.RegistrationListener? = null
+    @Volatile private var started = false
+
+    /**
+     * Begin advertising. Idempotent — a second [start] with the same
+     * config is a no-op.
+     */
+    fun start(
+        serviceName: String,
+        port: Int,
+        txt: Map<String, String>,
+    ) {
+        if (started) return
+        val info = NsdServiceInfo().apply {
+            this.serviceName = serviceName
+            this.serviceType = DVAI_NSD_SERVICE_TYPE
+            this.port = port
+            for ((k, v) in txt) {
+                setAttribute(k, v)
+            }
+        }
+        val l = object : NsdManager.RegistrationListener {
+            override fun onRegistrationFailed(info: NsdServiceInfo, errorCode: Int) {
+                Log.w(TAG, "registration failed code=$errorCode")
+                started = false
+            }
+
+            override fun onUnregistrationFailed(info: NsdServiceInfo, errorCode: Int) {
+                Log.w(TAG, "unregistration failed code=$errorCode")
+            }
+
+            override fun onServiceRegistered(info: NsdServiceInfo) {
+                Log.d(TAG, "registered: ${info.serviceName}")
+            }
+
+            override fun onServiceUnregistered(info: NsdServiceInfo) {
+                Log.d(TAG, "unregistered: ${info.serviceName}")
+            }
+        }
+        listener = l
+        try {
+            nsdManager.registerService(info, NsdManager.PROTOCOL_DNS_SD, l)
+            started = true
+        } catch (e: Throwable) {
+            Log.w(TAG, "registerService threw: ${e.message}")
+            listener = null
+        }
+    }
+
+    /** Unregister. Idempotent. */
+    fun stop() {
+        val l = listener ?: return
+        try {
+            nsdManager.unregisterService(l)
+        } catch (e: Throwable) {
+            Log.d(TAG, "unregisterService: ${e.message}")
+        }
+        listener = null
+        started = false
+    }
+}

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/discovery/NsdDiscovery.kt

@@ -0,0 +1,230 @@
+package co.deepvoiceai.bridge.shared.core.discovery
+
+import android.content.Context
+import android.net.nsd.NsdManager
+import android.net.nsd.NsdServiceInfo
+import android.util.Log
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Discovery events emitted by [NsdDiscovery]. Mirrors the TS
+ * `DiscoveryEvent` discriminated union.
+ */
+sealed class DiscoveryEvent {
+    data class PeerUp(val peer: Peer) : DiscoveryEvent()
+    data class PeerDown(val deviceId: String) : DiscoveryEvent()
+    data class Error(val message: String) : DiscoveryEvent()
+}
+
+/**
+ * mDNS / DNS-SD discovery for `_dvai-bridge._tcp` peers, backed by
+ * Android's [NsdManager].
+ *
+ * Lifecycle:
+ *
+ *   1. Construct with `Context.applicationContext` and a self deviceId
+ *      (so we filter out our own broadcast).
+ *   2. Call [start] from a coroutine. NsdManager runs on its own
+ *      thread; this class is just a thin wrapper.
+ *   3. Collect from [events] for `DiscoveryEvent.PeerUp/PeerDown/Error`.
+ *   4. Call [peers] for a snapshot.
+ *   5. Call [stop] to release the discovery listener.
+ *
+ * Thread-safety: the internal peer map is a `ConcurrentHashMap`, and
+ * NsdManager callbacks fire on its internal thread. Stale-peer GC
+ * runs piggybacked on each new event since NsdManager doesn't itself
+ * surface explicit "peer down" notifications when a device just goes
+ * silent (no service unregister).
+ */
+class NsdDiscovery(
+    private val context: Context,
+    private val selfDeviceId: String,
+    /** Peer is considered down after this many ms with no advertisement seen. */
+    private val peerTtlMs: Long = 90_000L,
+) {
+    companion object {
+        private const val TAG = "DvaiNsdDiscovery"
+    }
+
+    private val nsdManager: NsdManager =
+        context.applicationContext.getSystemService(Context.NSD_SERVICE) as NsdManager
+
+    private val peerMap = ConcurrentHashMap<String, Peer>()
+    private val pendingResolutions = ConcurrentHashMap<String, Boolean>()
+
+    private val _events = MutableSharedFlow<DiscoveryEvent>(
+        replay = 0,
+        extraBufferCapacity = 64,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+
+    /** Hot stream of discovery events. Always-on; drops oldest on overflow. */
+    val events: SharedFlow<DiscoveryEvent> = _events.asSharedFlow()
+
+    @Volatile private var listener: NsdManager.DiscoveryListener? = null
+    @Volatile private var started = false
+
+    /** Snapshot of currently-known peers. */
+    fun peers(): List<Peer> {
+        gcStale()
+        return peerMap.values.toList()
+    }
+
+    /** Begin discovering. Idempotent. */
+    fun start() {
+        if (started) return
+        val l = object : NsdManager.DiscoveryListener {
+            override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
+                _events.tryEmit(
+                    DiscoveryEvent.Error(
+                        "[DVAI/discovery] onStartDiscoveryFailed type=$serviceType code=$errorCode",
+                    ),
+                )
+            }
+
+            override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {
+                _events.tryEmit(
+                    DiscoveryEvent.Error(
+                        "[DVAI/discovery] onStopDiscoveryFailed type=$serviceType code=$errorCode",
+                    ),
+                )
+            }
+
+            override fun onDiscoveryStarted(serviceType: String) {
+                Log.d(TAG, "discovery started: $serviceType")
+            }
+
+            override fun onDiscoveryStopped(serviceType: String) {
+                Log.d(TAG, "discovery stopped: $serviceType")
+            }
+
+            override fun onServiceFound(serviceInfo: NsdServiceInfo) {
+                val key = serviceInfo.serviceName
+                if (pendingResolutions.putIfAbsent(key, true) != null) return
+                resolve(serviceInfo) { pendingResolutions.remove(key) }
+            }
+
+            override fun onServiceLost(serviceInfo: NsdServiceInfo) {
+                // NsdManager doesn't expose deviceId directly here — match by
+                // serviceName in our peer map (we store it as a synthetic key).
+                val name = serviceInfo.serviceName ?: return
+                val gone = peerMap.entries.firstOrNull { it.value.deviceName == name || it.key == name }
+                gone?.let {
+                    peerMap.remove(it.key)
+                    _events.tryEmit(DiscoveryEvent.PeerDown(it.key))
+                }
+            }
+        }
+        listener = l
+        try {
+            nsdManager.discoverServices(DVAI_NSD_SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, l)
+            started = true
+        } catch (e: Throwable) {
+            _events.tryEmit(
+                DiscoveryEvent.Error("[DVAI/discovery] discoverServices threw: ${e.message}"),
+            )
+        }
+    }
+
+    /** Stop and release resources. Idempotent. */
+    fun stop() {
+        val l = listener ?: return
+        try {
+            nsdManager.stopServiceDiscovery(l)
+        } catch (e: Throwable) {
+            // NsdManager throws IllegalArgumentException if the listener
+            // is already deregistered. Safe to ignore on shutdown.
+            Log.d(TAG, "stopServiceDiscovery: ${e.message}")
+        }
+        listener = null
+        started = false
+        peerMap.clear()
+        pendingResolutions.clear()
+    }
+
+    /**
+     * Resolve a discovered service to fetch its host/port + TXT record.
+     * NsdManager pre-API-34 has a known race where back-to-back
+     * resolveService calls fail; we serialize via [pendingResolutions].
+     */
+    private fun resolve(serviceInfo: NsdServiceInfo, onDone: () -> Unit) {
+        val cb = object : NsdManager.ResolveListener {
+            override fun onResolveFailed(info: NsdServiceInfo, errorCode: Int) {
+                onDone()
+                _events.tryEmit(
+                    DiscoveryEvent.Error(
+                        "[DVAI/discovery] onResolveFailed name=${info.serviceName} code=$errorCode",
+                    ),
+                )
+            }
+
+            override fun onServiceResolved(info: NsdServiceInfo) {
+                onDone()
+                handleResolved(info)
+            }
+        }
+        try {
+            nsdManager.resolveService(serviceInfo, cb)
+        } catch (e: Throwable) {
+            onDone()
+            _events.tryEmit(
+                DiscoveryEvent.Error("[DVAI/discovery] resolveService threw: ${e.message}"),
+            )
+        }
+    }
+
+    private fun handleResolved(info: NsdServiceInfo) {
+        val txt = readTxt(info)
+        // Filter out our own advertisement.
+        val peerDeviceId = txt[PeerTxtKeys.DEVICE_ID]
+        if (peerDeviceId == null || peerDeviceId == selfDeviceId) return
+
+        val host = info.host?.hostAddress ?: return
+        val port = info.port
+        // IPv6 literals must be wrapped in brackets in URLs.
+        val hostPart = if (host.contains(':')) "[$host]" else host
+        val secure = txt[PeerTxtKeys.SECURE]?.equals("true", ignoreCase = true) == true
+        val scheme = if (secure) "https" else "http"
+        val baseUrl = "$scheme://$hostPart:$port"
+
+        val peer = parsePeerTxt(txt, baseUrl) ?: return
+        val previous = peerMap.put(peer.deviceId, peer)
+        if (previous == null || previous.lastSeenAt < peer.lastSeenAt - 1000) {
+            _events.tryEmit(DiscoveryEvent.PeerUp(peer))
+        }
+    }
+
+    private fun readTxt(info: NsdServiceInfo): Map<String, String> {
+        // attributes is API 21+. The Android byte-array → String conversion
+        // is UTF-8 by spec.
+        val attrs = info.attributes ?: emptyMap()
+        return attrs.entries.associate { (k, v) ->
+            k to (v?.toString(Charsets.UTF_8) ?: "")
+        }
+    }
+
+    private fun gcStale() {
+        if (peerMap.isEmpty()) return
+        val cutoff = System.currentTimeMillis() - peerTtlMs
+        val stale = peerMap.entries.filter { it.value.lastSeenAt < cutoff }
+        for (entry in stale) {
+            peerMap.remove(entry.key)
+            _events.tryEmit(DiscoveryEvent.PeerDown(entry.key))
+        }
+    }
+
+    /** Static helpers for tests / library-side conversions. */
+    object NsdAttrs {
+        /**
+         * Build an NsdServiceInfo attributes-style map from a TXT map.
+         * Useful for round-trip tests of TXT serialization without
+         * requiring an actual NsdManager instance.
+         */
+        fun fromTxt(txt: Map<String, String>): Map<String, ByteArray> =
+            txt.mapValues { (_, v) -> v.toByteArray(Charsets.UTF_8) }
+    }
+}

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/discovery/Peer.kt

@@ -0,0 +1,138 @@
+package co.deepvoiceai.bridge.shared.core.discovery
+
+import kotlinx.serialization.Serializable
+
+/**
+ * Phase 3 — peer discovery types (Kotlin mirror of the TS `Peer` shape
+ * in `@dvai-bridge/core/src/discovery/types.ts`).
+ *
+ * A "peer" is another device running dvai-bridge that this device can
+ * (potentially) offload inference requests to. Peers are surfaced by
+ * one or more discovery sources — LAN mDNS via [NsdDiscovery], app-
+ * supplied static lists, rendezvous-paired (internet), or a host-app
+ * provided custom source.
+ */
+@Serializable
+data class Peer(
+    /** Stable per-install device ID of the peer. */
+    val deviceId: String,
+    /** Human-readable hint (Android device name, hostname, etc.). */
+    val deviceName: String,
+    /** Library SemVer the peer is running. */
+    val dvaiVersion: String,
+    /** OpenAI-compatible base URL the peer's local server exposes. */
+    val baseUrl: String,
+    /**
+     * Models the peer claims to have loaded right now. Used to filter
+     * peer eligibility — we only offload model X to a peer that already
+     * has model X loaded (loading from scratch on the peer is fine but
+     * defeats the latency win).
+     */
+    val loadedModels: List<String> = emptyList(),
+    /**
+     * Peer-reported capability map: { modelId → tok/s }. Treat as
+     * advisory only; the offload decider re-probes a peer with a small
+     * reachability+decode test before its first real offload request.
+     */
+    val capability: Map<String, Double> = emptyMap(),
+    /** Discovery source — useful for diagnostics and structured-error responses. */
+    val via: PeerSource,
+    /** Whether the peer's URL uses TLS. */
+    val secure: Boolean = false,
+    /** Last-seen unix ms — discovery sources update this. */
+    val lastSeenAt: Long = 0L,
+)
+
+@Serializable
+enum class PeerSource {
+    @kotlinx.serialization.SerialName("mdns")
+    MDNS,
+    @kotlinx.serialization.SerialName("static")
+    STATIC,
+    @kotlinx.serialization.SerialName("rendezvous")
+    RENDEZVOUS,
+    @kotlinx.serialization.SerialName("custom")
+    CUSTOM,
+}
+
+/**
+ * Service-type advertised on mDNS for dvai-bridge instances. Mirrors
+ * `MDNS_SERVICE_TYPE` from the TS reference. Note that NsdManager
+ * uses the short form `_dvai-bridge._tcp` (no trailing `.local` —
+ * the platform appends it).
+ */
+const val DVAI_NSD_SERVICE_TYPE: String = "_dvai-bridge._tcp"
+
+/**
+ * Field names in the TXT record advertised + parsed by the LAN
+ * discovery layer. Single source of truth — both [NsdAdvertiser]
+ * and [NsdDiscovery] reference these constants.
+ */
+object PeerTxtKeys {
+    const val DVAI_VERSION = "dvaiVersion"
+    const val DEVICE_ID = "deviceId"
+    const val DEVICE_NAME = "deviceName"
+    const val MODELS = "models"
+    const val CAPABILITY = "capability"
+    const val SECURE = "secure"
+}
+
+/**
+ * Parse a TXT-record map into a [Peer]. Returns null when required
+ * fields are missing (deviceId, dvaiVersion). Used by [NsdDiscovery]
+ * after `NsdManager.resolveService` resolves the host + port.
+ */
+fun parsePeerTxt(
+    txt: Map<String, String>,
+    baseUrl: String,
+    via: PeerSource = PeerSource.MDNS,
+    lastSeenAt: Long = System.currentTimeMillis(),
+): Peer? {
+    val deviceId = txt[PeerTxtKeys.DEVICE_ID]?.takeIf { it.isNotEmpty() } ?: return null
+    val dvaiVersion = txt[PeerTxtKeys.DVAI_VERSION]?.takeIf { it.isNotEmpty() } ?: return null
+    val deviceName = txt[PeerTxtKeys.DEVICE_NAME] ?: deviceId
+    val models = txt[PeerTxtKeys.MODELS]
+        ?.split(",")
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        ?: emptyList()
+    val capability = txt[PeerTxtKeys.CAPABILITY]
+        ?.split(",")
+        ?.mapNotNull { entry ->
+            val pivot = entry.indexOf(':')
+            if (pivot <= 0) return@mapNotNull null
+            val key = entry.substring(0, pivot).trim()
+            val value = entry.substring(pivot + 1).trim().toDoubleOrNull() ?: return@mapNotNull null
+            key to value
+        }
+        ?.toMap()
+        ?: emptyMap()
+    val secure = txt[PeerTxtKeys.SECURE]?.equals("true", ignoreCase = true) == true
+    return Peer(
+        deviceId = deviceId,
+        deviceName = deviceName,
+        dvaiVersion = dvaiVersion,
+        baseUrl = baseUrl,
+        loadedModels = models,
+        capability = capability,
+        via = via,
+        secure = secure,
+        lastSeenAt = lastSeenAt,
+    )
+}
+
+/**
+ * Serialize a peer to a TXT-record map ready for `NsdServiceInfo`.
+ * Inverse of [parsePeerTxt]. Caller is responsible for setting the
+ * port on the `NsdServiceInfo` separately.
+ */
+fun Peer.toTxt(): Map<String, String> = buildMap {
+    put(PeerTxtKeys.DEVICE_ID, deviceId)
+    put(PeerTxtKeys.DEVICE_NAME, deviceName)
+    put(PeerTxtKeys.DVAI_VERSION, dvaiVersion)
+    if (loadedModels.isNotEmpty()) put(PeerTxtKeys.MODELS, loadedModels.joinToString(","))
+    if (capability.isNotEmpty()) {
+        put(PeerTxtKeys.CAPABILITY, capability.entries.joinToString(",") { "${it.key}:${it.value}" })
+    }
+    if (secure) put(PeerTxtKeys.SECURE, "true")
+}

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/offload/OffloadConfig.kt

@@ -0,0 +1,42 @@
+package co.deepvoiceai.bridge.shared.core.offload
+
+import co.deepvoiceai.bridge.shared.core.discovery.Peer
+
+/**
+ * Configuration for distributed inference / device offload (Kotlin
+ * mirror of the TS `OffloadConfig` in
+ * `@dvai-bridge/core/src/offload/types.ts`).
+ *
+ * Offload is opt-in: pass an `OffloadConfig(enabled = true)` to
+ * `StartOptions.offload` to turn it on. Default is null = behave
+ * exactly like v2.x.
+ *
+ * @param enabled              Master switch. Default false.
+ * @param discoverLAN          Run mDNS / NsdManager discovery for LAN peers. Default true.
+ * @param minLocalCapability   Below this tok/s, look for a peer. Default 10.0.
+ * @param hardwareMinimum      v3.2 — hard floor for any local inference, in tok/s.
+ *                             Below this, the device is "too weak"; the SDK
+ *                             silently enters offload-only mode (no model
+ *                             download/load). The SDK does NOT throw and
+ *                             does NOT show any UI — consumers query
+ *                             [DVAIBridge.assessHardware] ahead of start()
+ *                             if they want to refuse to start on too-weak
+ *                             devices and surface their own UI. Default 3.0.
+ * @param rendezvousUrl        Optional rendezvous-server URL — enables internet path.
+ * @param knownPeers           Optional pre-known peers (skip discovery for them).
+ * @param onPairingRequest     Suspending callback returning approve/deny for incoming
+ *                             pairings. If null, [PairingPolicy.requests] Flow is the
+ *                             only path; if both are absent, default-deny applies.
+ *                             Mirrors the JS callback shape.
+ * @param onOffload            Diagnostic callback when a request is offloaded. Optional.
+ */
+data class OffloadConfig(
+    val enabled: Boolean = false,
+    val discoverLAN: Boolean = true,
+    val minLocalCapability: Double = 10.0,
+    val hardwareMinimum: Double = 3.0,
+    val rendezvousUrl: String? = null,
+    val knownPeers: List<Peer> = emptyList(),
+    val onPairingRequest: (suspend (Peer) -> Boolean)? = null,
+    val onOffload: ((Peer) -> Unit)? = null,
+)