@elizaos/app-core 2.0.11-beta.5 → 2.0.11-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/app-core",
-  "version": "2.0.11-beta.5",
+  "version": "2.0.11-beta.6",
   "description": "Shared application core for elizaOS white-label agent apps.",
   "type": "module",
   "license": "MIT",
@@ -150,22 +150,22 @@
     "three": "^0.184.0"
   },
   "optionalDependencies": {
-    "@elizaos/capacitor-appblocker": "2.0.11-beta.5",
-    "@elizaos/capacitor-bun-runtime": "2.0.11-beta.5",
-    "@elizaos/capacitor-camera": "2.0.11-beta.5",
-    "@elizaos/capacitor-canvas": "2.0.11-beta.5",
-    "@elizaos/capacitor-contacts": "2.0.11-beta.5",
-    "@elizaos/capacitor-gateway": "2.0.11-beta.5",
-    "@elizaos/capacitor-location": "2.0.11-beta.5",
-    "@elizaos/capacitor-messages": "2.0.11-beta.5",
-    "@elizaos/capacitor-mobile-agent-bridge": "2.0.11-beta.5",
-    "@elizaos/capacitor-mobile-signals": "2.0.11-beta.5",
-    "@elizaos/capacitor-phone": "2.0.11-beta.5",
-    "@elizaos/capacitor-screencapture": "2.0.11-beta.5",
-    "@elizaos/capacitor-swabble": "2.0.11-beta.5",
-    "@elizaos/capacitor-system": "2.0.11-beta.5",
-    "@elizaos/capacitor-talkmode": "2.0.11-beta.5",
-    "@elizaos/capacitor-websiteblocker": "2.0.11-beta.5",
+    "@elizaos/capacitor-appblocker": "2.0.11-beta.6",
+    "@elizaos/capacitor-bun-runtime": "2.0.11-beta.6",
+    "@elizaos/capacitor-camera": "2.0.11-beta.6",
+    "@elizaos/capacitor-canvas": "2.0.11-beta.6",
+    "@elizaos/capacitor-contacts": "2.0.11-beta.6",
+    "@elizaos/capacitor-gateway": "2.0.11-beta.6",
+    "@elizaos/capacitor-location": "2.0.11-beta.6",
+    "@elizaos/capacitor-messages": "2.0.11-beta.6",
+    "@elizaos/capacitor-mobile-agent-bridge": "2.0.11-beta.6",
+    "@elizaos/capacitor-mobile-signals": "2.0.11-beta.6",
+    "@elizaos/capacitor-phone": "2.0.11-beta.6",
+    "@elizaos/capacitor-screencapture": "2.0.11-beta.6",
+    "@elizaos/capacitor-swabble": "2.0.11-beta.6",
+    "@elizaos/capacitor-system": "2.0.11-beta.6",
+    "@elizaos/capacitor-talkmode": "2.0.11-beta.6",
+    "@elizaos/capacitor-websiteblocker": "2.0.11-beta.6",
     "sharp": "^0.34.5"
   },
   "dependencies": {
@@ -179,23 +179,23 @@
     "@capacitor/preferences": "^8.0.1",
     "@capacitor/push-notifications": "^8.0.0",
     "@clack/prompts": "^1.0.0",
-    "@elizaos/core": "2.0.11-beta.5",
-    "@elizaos/plugin-anthropic": "2.0.11-beta.5",
-    "@elizaos/plugin-browser": "2.0.11-beta.5",
-    "@elizaos/plugin-edge-tts": "2.0.11-beta.5",
-    "@elizaos/plugin-elizacloud": "2.0.11-beta.5",
-    "@elizaos/plugin-groq": "2.0.11-beta.5",
-    "@elizaos/plugin-health": "2.0.11-beta.5",
-    "@elizaos/plugin-local-inference": "2.0.11-beta.5",
-    "@elizaos/plugin-openai": "2.0.11-beta.5",
-    "@elizaos/plugin-registry": "2.0.11-beta.5",
-    "@elizaos/plugin-sql": "2.0.11-beta.5",
-    "@elizaos/plugin-wechat": "2.0.11-beta.5",
-    "@elizaos/plugin-workflow": "2.0.11-beta.5",
-    "@elizaos/shared": "2.0.11-beta.5",
-    "@elizaos/skills": "2.0.11-beta.5",
-    "@elizaos/ui": "2.0.11-beta.5",
-    "@elizaos/vault": "2.0.11-beta.5",
+    "@elizaos/core": "2.0.11-beta.6",
+    "@elizaos/plugin-anthropic": "2.0.11-beta.6",
+    "@elizaos/plugin-browser": "2.0.11-beta.6",
+    "@elizaos/plugin-edge-tts": "2.0.11-beta.6",
+    "@elizaos/plugin-elizacloud": "2.0.11-beta.6",
+    "@elizaos/plugin-groq": "2.0.11-beta.6",
+    "@elizaos/plugin-health": "2.0.11-beta.6",
+    "@elizaos/plugin-local-inference": "2.0.11-beta.6",
+    "@elizaos/plugin-openai": "2.0.11-beta.6",
+    "@elizaos/plugin-registry": "2.0.11-beta.6",
+    "@elizaos/plugin-sql": "2.0.11-beta.6",
+    "@elizaos/plugin-wechat": "2.0.11-beta.6",
+    "@elizaos/plugin-workflow": "2.0.11-beta.6",
+    "@elizaos/shared": "2.0.11-beta.6",
+    "@elizaos/skills": "2.0.11-beta.6",
+    "@elizaos/ui": "2.0.11-beta.6",
+    "@elizaos/vault": "2.0.11-beta.6",
     "@node-rs/argon2": "^2.0.2",
     "@upstash/redis": "^1.37.0",
     "chalk": "^5.3.0",
@@ -216,5 +216,5 @@
   },
   "module": "./index.js",
   "types": "./index.d.ts",
-  "gitHead": "3d7c571a6384249fb4c6cea103920adedd8f7b5f"
+  "gitHead": "61487df01a63da719a96b3b368cc63c45e22c092"
 }

package/platforms/android/app/src/main/elizavoice-jni/CMakeLists.txt

@@ -63,12 +63,37 @@ add_library(elizainference SHARED IMPORTED)
 set_target_properties(elizainference PROPERTIES
     IMPORTED_LOCATION "${ELIZAVOICE_PREBUILT_SO}")
 
+# The DYNAMIC-Vulkan variant of libelizainference.so links its ggml/llama/mtmd
+# backends as separate .so (so the GPU backend libggml-vulkan.so can dlopen the
+# device's libvulkan.so at runtime — only possible in the bionic app process,
+# never the musl agent). Import each dep that is staged alongside so the
+# elizavoicejni link resolves libelizainference's DT_NEEDED; the bionic loader
+# pulls them in when System.loadLibrary("elizainference") runs. A CPU-only
+# static-fused libelizainference.so has none of these siblings, so each import
+# is guarded on the file existing — both variants build from this one list.
+set(ELIZAVOICE_LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../jniLibs/${ANDROID_ABI}")
+set(ELIZAVOICE_DEP_TARGETS "")
+foreach(dep ggml ggml-base ggml-cpu ggml-vulkan llama llama-common mtmd)
+    if(EXISTS "${ELIZAVOICE_LIB_DIR}/lib${dep}.so")
+        add_library(eliza_dep_${dep} SHARED IMPORTED)
+        set_target_properties(eliza_dep_${dep} PROPERTIES
+            IMPORTED_LOCATION "${ELIZAVOICE_LIB_DIR}/lib${dep}.so")
+        list(APPEND ELIZAVOICE_DEP_TARGETS eliza_dep_${dep})
+    endif()
+endforeach()
+
 find_library(LOG_LIB log)
 
 add_library(elizavoicejni SHARED elizavoice-jni.cpp)
 target_include_directories(elizavoicejni PRIVATE "${ELIZAVOICE_FFI_INCLUDE_DIR}")
 target_compile_options(elizavoicejni PRIVATE -O2 -DNDEBUG)
-target_link_libraries(elizavoicejni PRIVATE elizainference ${LOG_LIB})
+# --allow-shlib-undefined: libggml-vulkan.so NEEDs the device's libvulkan.so,
+# which isn't a link input (it resolves from /system/lib64 at runtime in the
+# app process). The shim never calls vulkan symbols directly, so leaving that
+# transitive NEEDED unresolved at link time is correct.
+target_link_libraries(elizavoicejni PRIVATE
+    elizainference ${ELIZAVOICE_DEP_TARGETS} ${LOG_LIB})
+target_link_options(elizavoicejni PRIVATE "-Wl,--allow-shlib-undefined")
 
 message(STATUS "[elizavoice-jni] building bionic JNI bridge for ${ANDROID_ABI}")
 message(STATUS "[elizavoice-jni] FFI header: ${ELIZAVOICE_FFI_INCLUDE_DIR}")

package/platforms/android/app/src/main/elizavoice-jni/elizavoice-jni.cpp

@@ -1042,4 +1042,308 @@ Java_ai_elizaos_app_ElizaVoiceNative_nativeVadSelfTest(JNIEnv* env, jclass,
     return to_jstring(env, j);
 }
 
+// ── Text generation (LLM) ops — the GPU-accelerated text path ────────────
+//
+// Wrap the fused streaming-LLM ABI (eliza_inference_llm_stream_*), pooled
+// embeddings (eliza_inference_embed), end-of-turn scoring
+// (eliza_inference_llm_eot_score, ABI v11), and the tokenizer. When this JNI
+// host is built against the DYNAMIC-Vulkan libelizainference (libggml-vulkan.so
+// staged alongside it), llm_stream_open offloads the model to the GPU in the
+// bionic app process automatically — the path the musl bun agent cannot take.
+
+JNIEXPORT jint JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeLlmStreamSupported(JNIEnv*, jclass) {
+    return static_cast<jint>(eliza_inference_llm_stream_supported());
+}
+
+JNIEXPORT jint JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeEmbedSupported(JNIEnv*, jclass) {
+    return static_cast<jint>(eliza_inference_embed_supported());
+}
+
+JNIEXPORT jint JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeEotSupported(JNIEnv*, jclass) {
+    return static_cast<jint>(eliza_inference_llm_eot_supported());
+}
+
+// Tokenize text -> int[] token ids. addSpecial adds BOS; parseSpecial renders
+// special tokens (<|im_start|> etc.) from the input.
+JNIEXPORT jintArray JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeTokenize(JNIEnv* env, jclass,
+                                                    jlong ctxHandle,
+                                                    jstring jText,
+                                                    jboolean addSpecial,
+                                                    jboolean parseSpecial) {
+    auto* ctx = reinterpret_cast<EliInferenceContext*>(ctxHandle);
+    const std::string text = from_jstring(env, jText);
+    int* toks = nullptr;
+    size_t n = 0;
+    char* outError = nullptr;
+    const int rc = eliza_inference_tokenize(
+        ctx, text.c_str(), text.size(), addSpecial ? 1 : 0,
+        parseSpecial ? 1 : 0, &toks, &n, &outError);
+    if (rc != ELIZA_OK) {
+        throw_runtime(env, "tokenize", outError);
+        return nullptr;
+    }
+    jintArray out = env->NewIntArray(static_cast<jsize>(n));
+    if (out && n > 0) {
+        env->SetIntArrayRegion(out, 0, static_cast<jsize>(n),
+                               reinterpret_cast<const jint*>(toks));
+    }
+    if (toks) eliza_inference_free_tokens(toks);
+    return out;
+}
+
+// Pooled, L2-normalized sentence embedding (pooling: 1=MEAN default) ->
+// float[n_embd].
+JNIEXPORT jfloatArray JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeEmbed(JNIEnv* env, jclass,
+                                                 jlong ctxHandle, jstring jText,
+                                                 jint pooling) {
+    auto* ctx = reinterpret_cast<EliInferenceContext*>(ctxHandle);
+    const std::string text = from_jstring(env, jText);
+    std::vector<float> out(4096, 0.0f);
+    int dim = 0;
+    char* outError = nullptr;
+    const int rc = eliza_inference_embed(ctx, text.c_str(), text.size(),
+                                         pooling > 0 ? pooling : 1, out.data(),
+                                         out.size(), &dim, &outError);
+    if (rc != ELIZA_OK) {
+        throw_runtime(env, "embed", outError);
+        return nullptr;
+    }
+    jfloatArray ja = env->NewFloatArray(dim);
+    if (ja && dim > 0) env->SetFloatArrayRegion(ja, 0, dim, out.data());
+    return ja;
+}
+
+// End-of-turn score: next-token P(targetToken | tokens) -> float.
+JNIEXPORT jfloat JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeEotScore(JNIEnv* env, jclass,
+                                                    jlong ctxHandle,
+                                                    jintArray jTokens,
+                                                    jint targetToken) {
+    auto* ctx = reinterpret_cast<EliInferenceContext*>(ctxHandle);
+    const jsize n = env->GetArrayLength(jTokens);
+    std::vector<int32_t> toks(static_cast<size_t>(n));
+    if (n > 0) {
+        env->GetIntArrayRegion(jTokens, 0, n,
+                               reinterpret_cast<jint*>(toks.data()));
+    }
+    float prob = 0.0f, topProb = 0.0f;
+    int32_t topTok = -1;
+    char* outError = nullptr;
+    const int rc = eliza_inference_llm_eot_score(ctx, toks.data(), toks.size(),
+                                                 targetToken, &prob, &topTok,
+                                                 &topProb, &outError);
+    if (rc != ELIZA_OK) {
+        throw_runtime(env, "eot_score", outError);
+        return 0.0f;
+    }
+    return prob;
+}
+
+// Open a streaming-LLM session. nGpuLayers: -1 = all-GPU (default), 0 = CPU
+// (the lib ignores 0 when libggml-vulkan is linked; the CPU/GPU choice is the
+// staged LIB VARIANT, see the per-device selection). drafterPath ("" = none)
+// enables MTP speculative decoding.
+JNIEXPORT jlong JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeLlmStreamOpen(
+    JNIEnv* env, jclass, jlong ctxHandle, jint maxTokens, jfloat temperature,
+    jfloat topP, jint topK, jint nGpuLayers, jstring jDrafterPath) {
+    auto* ctx = reinterpret_cast<EliInferenceContext*>(ctxHandle);
+    const std::string drafter = from_jstring(env, jDrafterPath);
+    eliza_llm_stream_config_t cfg;
+    std::memset(&cfg, 0, sizeof(cfg));
+    cfg.max_tokens = maxTokens;
+    cfg.temperature = temperature;
+    cfg.top_p = topP > 0 ? topP : 1.0f;
+    cfg.top_k = topK;
+    cfg.repeat_penalty = 1.0f;
+    cfg.n_gpu_layers = nGpuLayers;
+    cfg.mtp_drafter_path = drafter.empty() ? nullptr : drafter.c_str();
+    char* outError = nullptr;
+    EliLlmStream* s = eliza_inference_llm_stream_open(ctx, &cfg, &outError);
+    if (!s) {
+        throw_runtime(env, "llm_stream_open returned null", outError);
+        return 0;
+    }
+    return reinterpret_cast<jlong>(s);
+}
+
+JNIEXPORT void JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeLlmStreamPrefill(JNIEnv* env, jclass,
+                                                            jlong streamHandle,
+                                                            jintArray jTokens) {
+    auto* s = reinterpret_cast<EliLlmStream*>(streamHandle);
+    const jsize n = env->GetArrayLength(jTokens);
+    std::vector<int32_t> toks(static_cast<size_t>(n));
+    if (n > 0) {
+        env->GetIntArrayRegion(jTokens, 0, n,
+                               reinterpret_cast<jint*>(toks.data()));
+    }
+    char* outError = nullptr;
+    const int rc = eliza_inference_llm_stream_prefill(s, toks.data(),
+                                                      toks.size(), &outError);
+    if (rc != ELIZA_OK) throw_runtime(env, "llm_stream_prefill", outError);
+}
+
+// Pull the next decode step. Returns JSON {text, done, drafted, accepted}:
+// `text` is the detokenized chunk (may span multiple committed tokens via MTP),
+// `done` true at the final step. `text` is JSON-escaped.
+JNIEXPORT jstring JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeLlmStreamNext(JNIEnv* env, jclass,
+                                                         jlong streamHandle) {
+    auto* s = reinterpret_cast<EliLlmStream*>(streamHandle);
+    int32_t toks[256];
+    char text[4096];
+    size_t nout = 0;
+    int32_t drafted = 0, accepted = 0;
+    char* outError = nullptr;
+    const int rc = eliza_inference_llm_stream_next(
+        s, toks, 256, &nout, text, sizeof(text), &drafted, &accepted, &outError);
+    if (rc < 0) {
+        throw_runtime(env, "llm_stream_next", outError);
+        return nullptr;
+    }
+    std::string esc;
+    for (const char* p = text; *p; ++p) {
+        switch (*p) {
+            case '"': esc += "\\\""; break;
+            case '\\': esc += "\\\\"; break;
+            case '\n': esc += "\\n"; break;
+            case '\r': esc += "\\r"; break;
+            case '\t': esc += "\\t"; break;
+            default:
+                if (static_cast<unsigned char>(*p) < 0x20) {
+                    char buf[8];
+                    std::snprintf(buf, sizeof(buf), "\\u%04x",
+                                  static_cast<unsigned char>(*p));
+                    esc += buf;
+                } else {
+                    esc += *p;
+                }
+        }
+    }
+    std::string json = "{\"text\":\"" + esc +
+                       "\",\"done\":" + (rc == 1 ? "true" : "false") +
+                       ",\"drafted\":" + std::to_string(drafted) +
+                       ",\"accepted\":" + std::to_string(accepted) + "}";
+    return to_jstring(env, json);
+}
+
+JNIEXPORT void JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeLlmStreamClose(JNIEnv*, jclass,
+                                                          jlong streamHandle) {
+    eliza_inference_llm_stream_close(
+        reinterpret_cast<EliLlmStream*>(streamHandle));
+}
+
+// ── LLM self-test (one native call: ctx→tokenize→stream→generate) ─────────
+//
+// THE KEYSTONE PROOF: runs a whole greedy text generation in ONE native call,
+// in the bionic app process, against whatever libelizainference.so is staged
+// into jniLibs. When that lib is the dynamic-Vulkan variant, ggml-vulkan logs
+// "Found 1 Vulkan devices: Mali-G715" + "offloaded N/N layers to GPU" to
+// logcat (the in-process GPU evidence). Returns JSON {ok,text,tokens,ms,tokS}.
+JNIEXPORT jstring JNICALL
+Java_ai_elizaos_app_ElizaVoiceNative_nativeLlmSelfTest(JNIEnv* env, jclass,
+                                                       jstring jBundleDir,
+                                                       jstring jPrompt,
+                                                       jint maxTokens) {
+    const std::string bundleDir = from_jstring(env, jBundleDir);
+    const std::string prompt = from_jstring(env, jPrompt);
+    const int genCap = maxTokens > 0 ? maxTokens : 32;
+    char* outError = nullptr;
+
+    EliInferenceContext* ctx =
+        eliza_inference_create(bundleDir.c_str(), &outError);
+    if (!ctx) { throw_runtime(env, "llmSelfTest: create", outError); return nullptr; }
+
+    int* tok = nullptr; size_t tn = 0;
+    if (eliza_inference_tokenize(ctx, prompt.c_str(), prompt.size(), 1, 1, &tok,
+                                 &tn, &outError) != ELIZA_OK) {
+        eliza_inference_destroy(ctx);
+        throw_runtime(env, "llmSelfTest: tokenize", outError);
+        return nullptr;
+    }
+
+    eliza_llm_stream_config_t cfg;
+    std::memset(&cfg, 0, sizeof(cfg));
+    cfg.max_tokens = genCap;
+    cfg.temperature = 0.0f;  // greedy, deterministic
+    cfg.top_k = 1;
+    cfg.top_p = 1.0f;
+    cfg.repeat_penalty = 1.0f;
+    cfg.n_gpu_layers = -1;   // all-GPU when the vulkan lib is staged
+    EliLlmStream* s = eliza_inference_llm_stream_open(ctx, &cfg, &outError);
+    if (!s) {
+        if (tok) eliza_inference_free_tokens(tok);
+        eliza_inference_destroy(ctx);
+        throw_runtime(env, "llmSelfTest: stream_open", outError);
+        return nullptr;
+    }
+
+    const double t0 = []() {
+        timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
+        return ts.tv_sec * 1000.0 + ts.tv_nsec / 1e6;
+    }();
+    if (eliza_inference_llm_stream_prefill(s, reinterpret_cast<int32_t*>(tok),
+                                           tn, &outError) != ELIZA_OK) {
+        eliza_inference_llm_stream_close(s);
+        if (tok) eliza_inference_free_tokens(tok);
+        eliza_inference_destroy(ctx);
+        throw_runtime(env, "llmSelfTest: prefill", outError);
+        return nullptr;
+    }
+
+    std::string text;
+    int produced = 0;
+    while (produced < genCap) {
+        int32_t toks[256]; char chunk[4096]; size_t nout = 0;
+        int32_t dd = 0, da = 0;
+        const int rc = eliza_inference_llm_stream_next(
+            s, toks, 256, &nout, chunk, sizeof(chunk), &dd, &da, &outError);
+        if (rc < 0) break;
+        text += chunk;
+        produced += static_cast<int>(nout);
+        if (rc == 1) break;
+    }
+    const double t1 = []() {
+        timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
+        return ts.tv_sec * 1000.0 + ts.tv_nsec / 1e6;
+    }();
+    eliza_inference_llm_stream_close(s);
+    if (tok) eliza_inference_free_tokens(tok);
+    eliza_inference_destroy(ctx);
+
+    const double ms = t1 - t0;
+    const double tokS = ms > 0 ? produced * 1000.0 / ms : 0.0;
+    LOGI("LLM SELFTEST: generated %d tokens in %.0fms (%.2f tok/s) — \"%.80s\"",
+         produced, ms, tokS, text.c_str());
+
+    // JSON-escape the generated text.
+    std::string esc;
+    for (char c : text) {
+        switch (c) {
+            case '"': esc += "\\\""; break;
+            case '\\': esc += "\\\\"; break;
+            case '\n': esc += "\\n"; break;
+            case '\r': esc += "\\r"; break;
+            case '\t': esc += "\\t"; break;
+            default:
+                if (static_cast<unsigned char>(c) < 0x20) {
+                    char b[8]; std::snprintf(b, sizeof(b), "\\u%04x",
+                                             static_cast<unsigned char>(c));
+                    esc += b;
+                } else esc += c;
+        }
+    }
+    std::string json = "{\"ok\":true,\"tokens\":" + std::to_string(produced) +
+                       ",\"ms\":" + std::to_string(ms) + ",\"tokS\":" +
+                       std::to_string(tokS) + ",\"text\":\"" + esc + "\"}";
+    return to_jstring(env, json);
+}
+
 }  // extern "C"

package/platforms/android/app/src/main/java/ai/elizaos/app/ElizaVoiceNative.java

@@ -157,4 +157,49 @@ final class ElizaVoiceNative {
 
     /** Run the whole pipeline (ctx→open→feed→flush) on one PCM buffer in one call. */
     static native String nativePipelineSelfTest(String bundleDir, float[] pcm, int feedSamples);
+
+    // ── Text generation (LLM) — the GPU-accelerated text path ────────────
+    //
+    // When this host is built against the dynamic-Vulkan libelizainference
+    // (libggml-vulkan.so staged alongside), llm_stream_open offloads the model
+    // to the GPU in the bionic app process — the path the musl bun agent can't
+    // take. nGpuLayers=-1 means all-GPU (default); the CPU/GPU choice is the
+    // staged LIB variant, not this flag.
+
+    /** {@code eliza_inference_llm_stream_supported()}. */
+    static native int nativeLlmStreamSupported();
+
+    /** {@code eliza_inference_embed_supported()}. */
+    static native int nativeEmbedSupported();
+
+    /** {@code eliza_inference_llm_eot_supported()} (ABI v11). */
+    static native int nativeEotSupported();
+
+    /** Tokenize text → int[] token ids. */
+    static native int[] nativeTokenize(long ctxHandle, String text, boolean addSpecial, boolean parseSpecial);
+
+    /** Pooled (MEAN) L2-normalized sentence embedding → float[n_embd]. */
+    static native float[] nativeEmbed(long ctxHandle, String text, int pooling);
+
+    /** End-of-turn score: next-token P(targetToken | tokens). */
+    static native float nativeEotScore(long ctxHandle, int[] tokens, int targetToken);
+
+    /** Open a streaming-LLM session (nGpuLayers=-1 all-GPU; drafterPath ""=none). */
+    static native long nativeLlmStreamOpen(long ctxHandle, int maxTokens, float temperature, float topP, int topK, int nGpuLayers, String drafterPath);
+
+    /** Feed pre-tokenized prompt tokens into the session KV before the first next(). */
+    static native void nativeLlmStreamPrefill(long streamHandle, int[] tokens);
+
+    /** Pull the next decode step → JSON {text, done, drafted, accepted}. */
+    static native String nativeLlmStreamNext(long streamHandle);
+
+    static native void nativeLlmStreamClose(long streamHandle);
+
+    /**
+     * KEYSTONE proof: run a whole greedy text generation in one native call,
+     * in the bionic app process. With the dynamic-Vulkan lib staged, ggml-vulkan
+     * logs the Mali device + layer offload to logcat. Returns JSON
+     * {ok, text, tokens, ms, tokS}.
+     */
+    static native String nativeLlmSelfTest(String bundleDir, String prompt, int maxTokens);
 }

package/platforms/android/app/src/main/java/ai/elizaos/app/ElizaVoicePlugin.java

@@ -164,6 +164,54 @@ public class ElizaVoicePlugin extends Plugin {
         }
     }
 
+    // ── Text generation (LLM) — GPU-accelerated path in the bionic app process ──
+
+    /**
+     * Capability probe for the text path. With the dynamic-Vulkan
+     * libelizainference staged, llmStream is supported and runs on the Mali GPU
+     * in THIS process (the musl bun agent can't reach libvulkan).
+     */
+    @PluginMethod
+    public void llmAbiProbe(PluginCall call) {
+        if (!ensureLoadedOrReject(call)) return;
+        try {
+            JSObject r = new JSObject();
+            r.put("loaded", true);
+            r.put("abi", ElizaVoiceNative.nativeVoiceAbiVersion());
+            r.put("llmStream", ElizaVoiceNative.nativeLlmStreamSupported());
+            r.put("embed", ElizaVoiceNative.nativeEmbedSupported());
+            r.put("eot", ElizaVoiceNative.nativeEotSupported());
+            Log.i(TAG, "llmAbiProbe " + r.toString());
+            call.resolve(r);
+        } catch (Throwable e) {
+            call.reject("llmAbiProbe failed: " + e.getMessage());
+        }
+    }
+
+    /**
+     * KEYSTONE proof: run a whole greedy generation in one native call, in the
+     * bionic app process. ggml-vulkan logs the Mali device + layer offload to
+     * logcat; the returned JSON carries {ok, text, tokens, ms, tokS}.
+     */
+    @PluginMethod
+    public void llmSelfTest(PluginCall call) {
+        if (!ensureLoadedOrReject(call)) return;
+        String bundleDir = resolveBundleDir(call.getString("bundleDir"));
+        String prompt = call.getString("prompt",
+            "<|im_start|>user\nWrite one sentence about the ocean.<|im_end|>\n<|im_start|>assistant\n");
+        Integer maxTokens = call.getInt("maxTokens", 48);
+        try {
+            String json = ElizaVoiceNative.nativeLlmSelfTest(
+                bundleDir, prompt, maxTokens != null ? maxTokens : 48);
+            Log.i(TAG, "llmSelfTest(" + bundleDir + ") -> " + json);
+            JSObject r = new JSObject();
+            r.put("result", json);
+            call.resolve(r);
+        } catch (Throwable e) {
+            call.reject("llmSelfTest failed: " + e.getMessage());
+        }
+    }
+
     private String resolveBundleDir(String requested) {
         if (requested != null && !requested.isEmpty()) return requested;
         Context context = getContext();

package/platforms/android/app/src/main/java/ai/elizaos/app/ResourceProbePlugin.java

@@ -162,7 +162,7 @@ public class ResourceProbePlugin extends Plugin {
                 ticksPerSecond = 100; // POSIX-conventional default on Android
             }
             return ((utime + stime) * 1000.0) / ticksPerSecond;
-        } catch (IOException | NumberFormatException | RuntimeException e) {
+        } catch (IOException | RuntimeException e) {
             return JSONObject.NULL;
         }
     }

package/platforms/electrobun/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/electrobun",
-  "version": "2.0.11-beta.5",
+  "version": "2.0.11-beta.6",
   "type": "module",
   "files": [
     "assets",
@@ -25,12 +25,12 @@
     "build:native-effects": "bash scripts/build-macos-effects.sh"
   },
   "dependencies": {
-    "@elizaos/agent": "2.0.11-beta.5",
-    "@elizaos/app-core": "2.0.11-beta.5",
-    "@elizaos/plugin-browser": "2.0.11-beta.5",
-    "@elizaos/plugin-registry": "2.0.11-beta.5",
-    "@elizaos/plugin-remote-manifest": "2.0.11-beta.5",
-    "@elizaos/shared": "2.0.11-beta.5",
+    "@elizaos/agent": "2.0.11-beta.6",
+    "@elizaos/app-core": "2.0.11-beta.6",
+    "@elizaos/plugin-browser": "2.0.11-beta.6",
+    "@elizaos/plugin-registry": "2.0.11-beta.6",
+    "@elizaos/plugin-remote-manifest": "2.0.11-beta.6",
+    "@elizaos/shared": "2.0.11-beta.6",
     "bonjour-service": "1.3.0",
     "electrobun": "^1.18.1"
   },
@@ -44,5 +44,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3d7c571a6384249fb4c6cea103920adedd8f7b5f"
+  "gitHead": "61487df01a63da719a96b3b368cc63c45e22c092"
 }