feat: implement Nexa SDK GGUF polymorphic backend & transparent live wallpaper

Author: vNeeL-code

app/build.gradle.kts

@@ -104,12 +104,14 @@ dependencies {
     // (NOT mediapipe:tasks-genai - that's a different/older API)
     implementation("com.google.ai.edge.litertlm:litertlm-android:0.9.0-alpha01")
 
+    // Nexa SDK: GGUF Model Inference Engine (Uncensored Llama-3, etc)
+    implementation("ai.nexa:core:0.0.24")
+    
     // TFLite GPU delegate - Use Google Play Services versions (like Gallery app)
     implementation("com.google.android.gms:play-services-tflite-java:16.4.0")
     implementation("com.google.android.gms:play-services-tflite-gpu:16.4.0")
     implementation("com.google.android.gms:play-services-tflite-support:16.4.0")
 
-
     implementation("androidx.core:core-ktx:1.13.1")
 
     // UI & Layouts

app/src/main/AndroidManifest.xml

@@ -133,6 +133,19 @@
                  Filtering to conversations|alerting was blocking all media notifications. -->
         </service>
 
+        <!-- TRANSPARENT CAMERA WALLPAPER -->
+        <service
+            android:name=".ui.CameraWallpaperService"
+            android:permission="android.permission.BIND_WALLPAPER"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.service.wallpaper.WallpaperService" />
+            </intent-filter>
+            <meta-data
+                android:name="android.service.wallpaper"
+                android:resource="@xml/transparent_wallpaper" />
+        </service>
+
         <!-- Launcher Activity (starts service and exits) -->
         <activity
             android:name=".MainActivity"

app/src/main/kotlin/com/gemma/api/ApiServer.kt

@@ -42,7 +42,6 @@ class ApiServer(
                         Timber.d("API: ${prompt.take(30)}...")
 
                         // DELEGATE TO GEMMA SERVICE (Orchestrator)
-                        // Storage is handled atomically inside processQuery
                         val aiResponse = withContext(Dispatchers.Default) {
                             gemmaService.processQuery(prompt, sessionId) ?: "Error: No response generated"
                         }
@@ -61,6 +60,80 @@ class ApiServer(
                     }
                 }
 
+                // STANDARD OPENAI-COMPATIBLE ENDPOINT FOR OPENCLAW / HONCHO
+                post("/v1/chat/completions") {
+                    try {
+                        val request = call.receiveText()
+                        val parsed = gson.fromJson(request, Map::class.java)
+                        
+                        @Suppress("UNCHECKED_CAST")
+                        val messages = parsed["messages"] as? List<Map<String, Any>> ?: emptyList()
+                        
+                        // Extract the query. For our stateful agent, we ideally just want the latest user message
+                        // since we maintain our own KV cache and SQLite history natively.
+                        val lastMessage = messages.lastOrNull()
+                        val content = lastMessage?.get("content")?.toString() ?: ""
+                        
+                        // Fallback: If it's a completely stateless external request, we might need all messages.
+                        // But Oracle_OS is inherently stateful. Let's just pass the payload contents.
+                        val promptBuilder = StringBuilder()
+                        if (messages.size > 1) {
+                            // If they passed history, let's concatenate loosely just in case
+                            for (msg in messages) {
+                                val role = msg["role"]?.toString() ?: "user"
+                                val text = msg["content"]?.toString() ?: ""
+                                promptBuilder.append("[\${role.uppercase()}]: \$text\n")
+                            }
+                        } else {
+                            promptBuilder.append(content)
+                        }
+                        
+                        val prompt = promptBuilder.toString().trim()
+                        val sessionId = "openclaw_session"
+
+                        Timber.d("OpenAI API: \${prompt.take(50)}...")
+
+                        val aiResponse = withContext(Dispatchers.Default) {
+                            gemmaService.processQuery(prompt, sessionId) ?: "Error: No response generated"
+                        }
+
+                        // Build OpenAI Schema conformant response
+                        val responseMap = mapOf(
+                            "id" to "chatcmpl-\${UUID.randomUUID()}",
+                            "object" to "chat.completion",
+                            "created" to (System.currentTimeMillis() / 1000),
+                            "model" to (parsed["model"]?.toString() ?: "gemma-local"),
+                            "choices" to listOf(
+                                mapOf(
+                                    "index" to 0,
+                                    "message" to mapOf(
+                                        "role" to "assistant",
+                                        "content" to aiResponse
+                                    ),
+                                    "finish_reason" to "stop"
+                                )
+                            ),
+                            "usage" to mapOf(
+                                "prompt_tokens" to prompt.length / 4,
+                                "completion_tokens" to aiResponse.length / 4,
+                                "total_tokens" to (prompt.length + aiResponse.length) / 4
+                            )
+                        )
+
+                        call.respondText(gson.toJson(responseMap), ContentType.Application.Json)
+                    } catch (e: Exception) {
+                        Timber.e(e, "OpenAI API error")
+                        val errorJson = gson.toJson(mapOf(
+                            "error" to mapOf(
+                                "message" to (e.message ?: "Unknown error"),
+                                "type" to "server_error",
+                                "code" to 500
+                            )
+                        ))
+                        call.respondText(errorJson, ContentType.Application.Json, HttpStatusCode.InternalServerError)
+                    }
+                }
+                
                 // ... (Keep existing GET routes) ...
 
                 get("/context") {

app/src/main/kotlin/com/gemma/api/GemmaEngine.kt

@@ -25,15 +25,15 @@ import kotlin.coroutines.resumeWithException
  * Uses the proper Google AI Edge LiteRT-LM library for Gemma 3n inference
  * with full support for images and audio (omnimodal!)
  */
-class GemmaEngine(private val context: Context) {
+class GemmaEngine(private val context: Context) : LlmBackend {
 
     private var engine: Engine? = null
     private var conversation: Conversation? = null
     private val sessionLock = Object()
 
     @Volatile private var isResetting = false
 
-    var activeBackend: String? = null
+    override var activeBackend: String? = null
         private set
 
     // Phase 12: Cache initialization params for hardReset
@@ -103,10 +103,10 @@ class GemmaEngine(private val context: Context) {
         }
     }
 
-    suspend fun generateResponse(
+    override suspend fun generateResponse(
         prompt: String,
-        images: List<Bitmap> = emptyList(),
-        audioData: ByteArray? = null
+        images: List<Bitmap>,
+        audioData: ByteArray?
     ): String {
         // Wait if reset is in progress or conversation is transiently null
         var waitCount = 0
@@ -207,10 +207,10 @@ class GemmaEngine(private val context: Context) {
         }
     }
 
-    fun streamResponse(
+    override fun streamResponse(
         prompt: String,
-        images: List<Bitmap> = emptyList(),
-        audioData: ByteArray? = null,
+        images: List<Bitmap>,
+        audioData: ByteArray?,
         onToken: (String) -> Unit,
         onComplete: (String) -> Unit,
         onError: (String) -> Unit
@@ -267,7 +267,8 @@ class GemmaEngine(private val context: Context) {
         }
     }
 
-    fun softReset(systemPrompt: String) {
+    override fun softReset(systemPrompt: String) {
+        Timber.i("GemmaEngine Soft Reset with robust prompt injection")
         isResetting = true
         try {
             synchronized(sessionLock) {
@@ -299,7 +300,7 @@ class GemmaEngine(private val context: Context) {
     }
 
     // Phase 12: Implement hardReset to cure Hexagon DSP NPU hardware timeouts.
-    fun hardReset() {
+    override fun hardReset() {
         if (lastModelPath.isBlank()) {
             Timber.e("Cannot hard reset: Engine was never initialized")
             return
@@ -373,7 +374,8 @@ class GemmaEngine(private val context: Context) {
      * Creates a temporary conversation, runs inference, cleans up.
      * Used by RLM for recursive sub-calls that shouldn't pollute the main conversation.
      */
-    suspend fun generateOneShot(prompt: String): String {
+    override suspend fun generateOneShot(prompt: String): String {
+        Timber.i("Executing one-shot prompt...")
         val currentEngine = synchronized(sessionLock) { engine }
             ?: return "Error: Engine not initialized"
 
@@ -454,7 +456,7 @@ class GemmaEngine(private val context: Context) {
         }
     }
 
-    fun cleanup() {
+    override fun cleanup() {
         runCatching {
             synchronized(sessionLock) {
                 conversation?.close()

app/src/main/kotlin/com/gemma/api/GemmaService.kt

@@ -71,10 +71,10 @@ class GemmaService : Service(), AgentPlatformCallbacks {
 
     // REPLACE: private lateinit var engine: GemmaEngine
     // WITH:
-    private val engineRef = AtomicReference<GemmaEngine?>(null)
+    private val engineRef = AtomicReference<LlmBackend?>(null)
     private val engineMutex = kotlinx.coroutines.sync.Mutex()
 
-    val engine: GemmaEngine?
+    val engine: LlmBackend?
         get() = engineRef.get()
 
     fun isGemmaLoaded(): Boolean = engineRef.get()?.let { 
@@ -601,50 +601,71 @@ class GemmaService : Service(), AgentPlatformCallbacks {
             val modelNames = listOf(
                 "gemma-3n-E4B-it-int4.litertlm",
                 "gemma-3n-E2B-it-int4.litertlm",
-                "gemma.litertlm"
+                "gemma.litertlm",
+                "model.gguf" // Add support for catching GGUF models directly
             )
+            // Let it find ANY .gguf file as a fallback if explicit name isn't matched
             val searchDirs = listOf(
                 getExternalFilesDir(null),  // App storage (survives Downloads cleanup)
                 downloadDir                  // Downloads folder
             )
-            val modelFile = searchDirs.flatMap { dir ->
+            
+            // Modified: Search for explicit model names first, if not found, scan for any .gguf
+            var modelFile = searchDirs.flatMap { dir ->
                 modelNames.map { name -> File(dir, name) }
             }.firstOrNull { it.exists() }
+            
+            if (modelFile == null) {
+                // Secondary heuristic: Pick any .gguf file available
+                modelFile = searchDirs.mapNotNull { dir ->
+                    dir?.listFiles { _, name -> name.endsWith(".gguf") || name.endsWith(".nexa") }?.firstOrNull()
+                }.firstOrNull()
+            }
 
             if (modelFile != null) {
                 val variant = when {
                     modelFile.name.contains("E4B") -> "E4B (full)"
                     modelFile.name.contains("E2B") -> "E2B (lite)"
+                    modelFile.name.endsWith(".gguf") -> "GGUF Open Weights"
                     else -> "unknown variant"
                 }
                 Timber.i("📦 Found model: ${modelFile.name} ($variant) in ${modelFile.parent}")
             }
 
             if (modelFile == null) {
                 val searchedPaths = searchDirs.mapNotNull { it?.absolutePath }
-                Timber.e("No model found! Searched: $searchedPaths for: $modelNames")
-                updateNotification("ERROR: No model found. Place .litertlm in app folder or Downloads")
+                Timber.e("No model found! Searched: $searchedPaths")
+                updateNotification("ERROR: No model found. Place .litertlm or .gguf in app folder/Downloads")
                 return
             }
 
-            updateNotification("Loading Gemma...")
-            val newEngine = GemmaEngine(applicationContext)
-            // Pass empty system prompt here — KoogAgent.initialize() sets the real one
-            // via softReset(buildSystemPrompt()) immediately after engine init.
-            // Previously BASE_SYSTEM_PROMPT was injected here AND buildSystemPrompt() was
-            // called on first flush, creating two competing identities on cold start.
-            val error = newEngine.initialize(modelFile.absolutePath, "")
-            if (error != null) {
-                val hint = when {
-                    error.contains("memory", ignoreCase = true) || error.contains("OOM", ignoreCase = true) ->
-                        " (Try E2B model on this device)"
-                    error.contains("GPU", ignoreCase = true) ->
-                        " (GPU init failed — device may not support this model)"
-                    else -> ""
+            updateNotification("Loading Model Core...")
+            
+            val newEngine: LlmBackend = if (modelFile.name.endsWith(".gguf") || modelFile.name.endsWith(".nexa")) {
+                NexaEngine(applicationContext).apply {
+                    val error = initialize(modelFile.absolutePath, "")
+                    if (error != null) {
+                        Timber.e("NexaEngine load failed: $error")
+                        updateNotification("GGUF Load Error: ${error.take(80)}")
+                        return
+                    }
+                }
+            } else {
+                GemmaEngine(applicationContext).apply {
+                    val error = initialize(modelFile.absolutePath, "")
+                    if (error != null) {
+                        val hint = when {
+                            error.contains("memory", ignoreCase = true) || error.contains("OOM", ignoreCase = true) ->
+                                " (Try E2B model on this device)"
+                            error.contains("GPU", ignoreCase = true) ->
+                                " (GPU init failed — device may not support this model)"
+                            else -> ""
+                        }
+                        Timber.e("GemmaEngine load failed: $error")
+                        updateNotification("LiteRT Load Error: ${error.take(80)}$hint")
+                        return
+                    }
                 }
-                Timber.e("Model load failed: $error")
-                updateNotification("Load Error: ${error.take(80)}$hint")
-                return
             }
 
             // Atomic set (Kimi K2 Fix)

app/src/main/kotlin/com/gemma/api/LlmBackend.kt

@@ -0,0 +1,27 @@
+package com.gemma.api
+
+import android.graphics.Bitmap
+
+interface LlmBackend {
+    val activeBackend: String?
+    fun softReset(systemPrompt: String)
+    fun hardReset()
+    fun cleanup()
+    
+    suspend fun generateOneShot(prompt: String): String
+    
+    suspend fun generateResponse(
+        prompt: String,
+        images: List<Bitmap> = emptyList(),
+        audioData: ByteArray? = null
+    ): String
+    
+    fun streamResponse(
+        prompt: String,
+        images: List<Bitmap> = emptyList(),
+        audioData: ByteArray? = null,
+        onToken: (String) -> Unit,
+        onComplete: (String) -> Unit,
+        onError: (String) -> Unit
+    )
+}

app/src/main/kotlin/com/gemma/api/MainActivity.kt

@@ -81,6 +81,7 @@ class MainActivity : Activity(), GemmaService.UiCallback {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        actionBar?.hide()
         Timber.i("🌀 Entering the System Check...")
 
         // Init Voice
@@ -283,6 +284,30 @@ class MainActivity : Activity(), GemmaService.UiCallback {
         btnSend = findViewById(R.id.btnSend)
         thinkingProgress = findViewById(R.id.thinkingProgress)
         thinkingText = findViewById(R.id.thinkingText)
+        val btnSettings = findViewById<android.view.View>(R.id.btnSettings)
+        
+        btnSettings?.setOnClickListener { view ->
+            val popup = android.widget.PopupMenu(this, view)
+            popup.menuInflater.inflate(R.menu.chat_settings_menu, popup.menu)
+            popup.setOnMenuItemClickListener { item ->
+                when (item.itemId) {
+                    R.id.action_transparent_wallpaper -> {
+                        try {
+                            val intent = Intent(android.app.WallpaperManager.ACTION_CHANGE_LIVE_WALLPAPER).apply {
+                                putExtra(android.app.WallpaperManager.EXTRA_LIVE_WALLPAPER_COMPONENT, 
+                                    ComponentName(this@MainActivity, com.gemma.api.ui.CameraWallpaperService::class.java))
+                            }
+                            startActivity(intent)
+                        } catch (e: Exception) {
+                            Timber.e(e, "Setup Live Wallpaper Intent Failed")
+                        }
+                        true
+                    }
+                    else -> false
+                }
+            }
+            popup.show()
+        }
 
         chatAdapter = ChatAdapter()
         chatRecyclerView?.apply {