capacitor-native-agent 0.3.5 → 0.3.6

package/Package.swift

@@ -11,7 +11,8 @@ let package = Package(
         )
     ],
     dependencies: [
-        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"),
+        .package(path: "../capacitor-lancedb")
     ],
     targets: [
         .binaryTarget(
@@ -23,6 +24,7 @@ let package = Package(
             dependencies: [
                 .product(name: "Capacitor", package: "capacitor-swift-pm"),
                 .product(name: "Cordova", package: "capacitor-swift-pm"),
+                .product(name: "CapacitorLancedb", package: "capacitor-lancedb"),
                 "NativeAgentFFI"
             ],
             path: "ios/Sources/NativeAgentPlugin",

package/android/build.gradle

@@ -22,6 +22,7 @@ kotlin {
 
 dependencies {
     implementation project(':capacitor-android')
+    compileOnly project(':capacitor-lancedb')
     implementation 'net.java.dev.jna:jna:5.14.0@aar'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1'
 }

package/android/src/main/java/com/t6x/plugins/nativeagent/LanceDBBridge.kt

@@ -0,0 +1,27 @@
+package com.t6x.plugins.nativeagent
+
+import android.content.Context
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import uniffi.lancedb_ffi.LanceDbHandle
+
+object LanceDBBridge {
+    const val EMBEDDING_DIM = 1536
+
+    @Volatile
+    private var handle: LanceDbHandle? = null
+
+    fun getOrCreateHandle(context: Context): LanceDbHandle? {
+        handle?.let { return it }
+        synchronized(this) {
+            handle?.let { return it }
+            val dbPath = File(context.filesDir, "lancedb-memories").absolutePath
+            handle = runCatching {
+                runBlocking {
+                    LanceDbHandle.open(dbPath, EMBEDDING_DIM)
+                }
+            }.getOrNull()
+            return handle
+        }
+    }
+}

package/android/src/main/java/com/t6x/plugins/nativeagent/MemoryProviderImpl.kt

@@ -0,0 +1,177 @@
+package com.t6x.plugins.nativeagent
+
+import android.content.Context
+import java.util.Locale
+import java.util.UUID
+import kotlinx.coroutines.runBlocking
+import org.json.JSONArray
+import org.json.JSONObject
+import uniffi.lancedb_ffi.HybridSearchResult
+import uniffi.lancedb_ffi.SearchResult
+import uniffi.native_agent_ffi.MemoryProvider
+
+class MemoryProviderImpl(private val context: Context) : MemoryProvider {
+    fun isAvailable(): Boolean = LanceDBBridge.getOrCreateHandle(context) != null
+
+    override fun store(key: String, text: String, metadataJson: String?): String {
+        val handle = LanceDBBridge.getOrCreateHandle(context) ?: return unavailableJson()
+        val resolvedKey = key.ifBlank {
+            "mem-${System.currentTimeMillis()}-${UUID.randomUUID().toString().take(8)}"
+        }
+        val embedding = localHashEmbed(text, LanceDBBridge.EMBEDDING_DIM)
+        return runCatching {
+            runBlocking {
+                handle.store(resolvedKey, DEFAULT_AGENT_ID, text, embedding, metadataJson)
+            }
+            JSONObject()
+                .put("success", true)
+                .put("key", resolvedKey)
+                .toString()
+        }.getOrElse { errorJson(it) }
+    }
+
+    override fun recall(query: String, limit: UInt): String {
+        val handle = LanceDBBridge.getOrCreateHandle(context) ?: return unavailableJson()
+        val embedding = localHashEmbed(query, LanceDBBridge.EMBEDDING_DIM)
+        return runCatching {
+            val results = runBlocking {
+                handle.hybridSearch(
+                    embedding,
+                    query,
+                    limit,
+                    "agent_id = '$DEFAULT_AGENT_ID'",
+                    null,
+                    null,
+                )
+            }
+            hybridResultsJson(results)
+        }.getOrElse { errorJson(it) }
+    }
+
+    override fun forget(key: String): String {
+        val handle = LanceDBBridge.getOrCreateHandle(context) ?: return unavailableJson()
+        if (key.isBlank()) {
+            return JSONObject().put("error", "Provide query or key.").toString()
+        }
+        return runCatching {
+            runBlocking {
+                handle.delete(key)
+            }
+            JSONObject()
+                .put("success", true)
+                .put("key", key)
+                .toString()
+        }.getOrElse { errorJson(it) }
+    }
+
+    override fun search(query: String, maxResults: UInt): String {
+        val handle = LanceDBBridge.getOrCreateHandle(context) ?: return unavailableJson()
+        val embedding = localHashEmbed(query, LanceDBBridge.EMBEDDING_DIM)
+        return runCatching {
+            val results = runBlocking {
+                handle.search(embedding, maxResults, "agent_id = '$DEFAULT_AGENT_ID'")
+            }
+            searchResultsJson(results)
+        }.getOrElse { errorJson(it) }
+    }
+
+    override fun list(prefix: String?, limit: UInt?): String {
+        val handle = LanceDBBridge.getOrCreateHandle(context) ?: return unavailableJson()
+        return runCatching {
+            val keys = runBlocking {
+                handle.list(prefix, limit)
+            }
+            JSONArray(keys).toString()
+        }.getOrElse { errorJson(it) }
+    }
+
+    private fun hybridResultsJson(results: List<HybridSearchResult>): String {
+        val array = JSONArray()
+        results.forEach { result ->
+            array.put(
+                JSONObject()
+                    .put("key", result.key)
+                    .put("text", result.text)
+                    .put("vectorRank", result.vectorRank.toInt())
+                    .put("textRank", result.textRank.toInt())
+                    .put("rrfScore", result.rrfScore)
+                    .apply {
+                        result.metadata?.let { put("metadata", it) }
+                    }
+            )
+        }
+        return array.toString()
+    }
+
+    private fun searchResultsJson(results: List<SearchResult>): String {
+        val array = JSONArray()
+        results.forEach { result ->
+            array.put(
+                JSONObject()
+                    .put("key", result.key)
+                    .put("text", result.text)
+                    .put("score", result.score)
+                    .apply {
+                        result.metadata?.let { put("metadata", it) }
+                    }
+            )
+        }
+        return array.toString()
+    }
+
+    private fun unavailableJson(): String {
+        return JSONObject().put("error", "Memory provider not configured").toString()
+    }
+
+    private fun errorJson(error: Throwable): String {
+        return JSONObject()
+            .put("error", error.message ?: error::class.java.simpleName)
+            .toString()
+    }
+
+    private companion object {
+        private const val DEFAULT_AGENT_ID = "main"
+        private val WHITESPACE = Regex("\\s+")
+        private val UINT_MAX_DOUBLE = 0xffffffffu.toDouble()
+        private const val FNV_OFFSET = 0x811c9dc5u
+        private const val FNV_PRIME = 0x01000193u
+        private const val GOLDEN_RATIO = 2654435761u
+        private const val MIX = 0x45d9f3bu
+
+        private fun fnv1a(text: String): UInt {
+            var hash = FNV_OFFSET
+            text.forEach { char ->
+                hash = hash xor char.code.toUInt()
+                hash *= FNV_PRIME
+            }
+            return hash
+        }
+
+        private fun seededRandom(seed: UInt, dim: Int): Float {
+            var h = seed xor (dim.toUInt() * GOLDEN_RATIO)
+            h = (((h shr 16) xor h) * MIX)
+            h = (((h shr 16) xor h) * MIX)
+            h = (h shr 16) xor h
+            return (((h.toDouble() / UINT_MAX_DOUBLE) * 2.0) - 1.0).toFloat()
+        }
+
+        private fun localHashEmbed(text: String, dim: Int): List<Float> {
+            val tokens = text.lowercase(Locale.ROOT).split(WHITESPACE).filter { it.isNotBlank() }
+            val vector = DoubleArray(dim)
+            tokens.forEach { token ->
+                val hash = fnv1a(token)
+                for (index in 0 until dim) {
+                    vector[index] += seededRandom(hash, index).toDouble()
+                }
+            }
+
+            var norm = 0.0
+            for (value in vector) {
+                norm += value * value
+            }
+            norm = kotlin.math.sqrt(norm).takeIf { it > 0.0 } ?: 1.0
+
+            return List(dim) { index -> (vector[index] / norm).toFloat() }
+        }
+    }
+}

package/android/src/main/java/com/t6x/plugins/nativeagent/NativeAgentPlugin.kt

@@ -93,6 +93,12 @@ class NativeAgentPlugin : Plugin() {
                     }
                 })
                 h.setNotifier(NativeNotifierImpl(context.applicationContext))
+                runCatching {
+                    val memoryProvider = MemoryProviderImpl(context.applicationContext)
+                    if (memoryProvider.isAvailable()) {
+                        h.setMemoryProvider(memoryProvider)
+                    }
+                }
                 h.persistConfig()
                 handle = h
                 context

package/android/src/main/java/uniffi/native_agent_ffi/native_agent_ffi.kt

@@ -654,12 +654,55 @@ internal open class UniffiForeignFutureStructVoid(
 internal interface UniffiForeignFutureCompleteVoid : com.sun.jna.Callback {
     fun callback(`callbackData`: Long,`result`: UniffiForeignFutureStructVoid.UniffiByValue,)
 }
+internal interface UniffiCallbackInterfaceMemoryProviderMethod0 : com.sun.jna.Callback {
+    fun callback(`uniffiHandle`: Long,`key`: RustBuffer.ByValue,`text`: RustBuffer.ByValue,`metadataJson`: RustBuffer.ByValue,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,)
+}
+internal interface UniffiCallbackInterfaceMemoryProviderMethod1 : com.sun.jna.Callback {
+    fun callback(`uniffiHandle`: Long,`query`: RustBuffer.ByValue,`limit`: Int,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,)
+}
+internal interface UniffiCallbackInterfaceMemoryProviderMethod2 : com.sun.jna.Callback {
+    fun callback(`uniffiHandle`: Long,`key`: RustBuffer.ByValue,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,)
+}
+internal interface UniffiCallbackInterfaceMemoryProviderMethod3 : com.sun.jna.Callback {
+    fun callback(`uniffiHandle`: Long,`query`: RustBuffer.ByValue,`maxResults`: Int,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,)
+}
+internal interface UniffiCallbackInterfaceMemoryProviderMethod4 : com.sun.jna.Callback {
+    fun callback(`uniffiHandle`: Long,`prefix`: RustBuffer.ByValue,`limit`: RustBuffer.ByValue,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,)
+}
 internal interface UniffiCallbackInterfaceNativeEventCallbackMethod0 : com.sun.jna.Callback {
     fun callback(`uniffiHandle`: Long,`eventType`: RustBuffer.ByValue,`payloadJson`: RustBuffer.ByValue,`uniffiOutReturn`: Pointer,uniffiCallStatus: UniffiRustCallStatus,)
 }
 internal interface UniffiCallbackInterfaceNativeNotifierMethod0 : com.sun.jna.Callback {
     fun callback(`uniffiHandle`: Long,`title`: RustBuffer.ByValue,`body`: RustBuffer.ByValue,`dataJson`: RustBuffer.ByValue,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,)
 }
+@Structure.FieldOrder("store", "recall", "forget", "search", "list", "uniffiFree")
+internal open class UniffiVTableCallbackInterfaceMemoryProvider(
+    @JvmField internal var `store`: UniffiCallbackInterfaceMemoryProviderMethod0? = null,
+    @JvmField internal var `recall`: UniffiCallbackInterfaceMemoryProviderMethod1? = null,
+    @JvmField internal var `forget`: UniffiCallbackInterfaceMemoryProviderMethod2? = null,
+    @JvmField internal var `search`: UniffiCallbackInterfaceMemoryProviderMethod3? = null,
+    @JvmField internal var `list`: UniffiCallbackInterfaceMemoryProviderMethod4? = null,
+    @JvmField internal var `uniffiFree`: UniffiCallbackInterfaceFree? = null,
+) : Structure() {
+    class UniffiByValue(
+        `store`: UniffiCallbackInterfaceMemoryProviderMethod0? = null,
+        `recall`: UniffiCallbackInterfaceMemoryProviderMethod1? = null,
+        `forget`: UniffiCallbackInterfaceMemoryProviderMethod2? = null,
+        `search`: UniffiCallbackInterfaceMemoryProviderMethod3? = null,
+        `list`: UniffiCallbackInterfaceMemoryProviderMethod4? = null,
+        `uniffiFree`: UniffiCallbackInterfaceFree? = null,
+    ): UniffiVTableCallbackInterfaceMemoryProvider(`store`,`recall`,`forget`,`search`,`list`,`uniffiFree`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiVTableCallbackInterfaceMemoryProvider) {
+        `store` = other.`store`
+        `recall` = other.`recall`
+        `forget` = other.`forget`
+        `search` = other.`search`
+        `list` = other.`list`
+        `uniffiFree` = other.`uniffiFree`
+    }
+
+}
 @Structure.FieldOrder("onEvent", "uniffiFree")
 internal open class UniffiVTableCallbackInterfaceNativeEventCallback(
     @JvmField internal var `onEvent`: UniffiCallbackInterfaceNativeEventCallbackMethod0? = null,
@@ -833,6 +876,14 @@ internal open class UniffiVTableCallbackInterfaceNativeNotifier(
 
 
 
+
+
+
+
+
+
+
+
 
 
 
@@ -852,6 +903,7 @@ internal interface UniffiLib : Library {
             .also { lib: UniffiLib ->
                 uniffiCheckContractApiVersion(lib)
                 uniffiCheckApiChecksums(lib)
+                uniffiCallbackInterfaceMemoryProvider.register(lib)
                 uniffiCallbackInterfaceNativeEventCallback.register(lib)
                 uniffiCallbackInterfaceNativeNotifier.register(lib)
                 }
@@ -935,6 +987,8 @@ internal interface UniffiLib : Library {
     ): Unit
     fun uniffi_native_agent_ffi_fn_method_nativeagenthandle_set_heartbeat_config(`ptr`: Pointer,`configJson`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
     ): Unit
+    fun uniffi_native_agent_ffi_fn_method_nativeagenthandle_set_memory_provider(`ptr`: Pointer,`provider`: Long,uniffi_out_err: UniffiRustCallStatus, 
+    ): Unit
     fun uniffi_native_agent_ffi_fn_method_nativeagenthandle_set_notifier(`ptr`: Pointer,`notifier`: Long,uniffi_out_err: UniffiRustCallStatus, 
     ): Unit
     fun uniffi_native_agent_ffi_fn_method_nativeagenthandle_set_scheduler_config(`ptr`: Pointer,`configJson`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
@@ -949,6 +1003,8 @@ internal interface UniffiLib : Library {
     ): Unit
     fun uniffi_native_agent_ffi_fn_method_nativeagenthandle_update_skill(`ptr`: Pointer,`id`: RustBuffer.ByValue,`patchJson`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
     ): Unit
+    fun uniffi_native_agent_ffi_fn_init_callback_vtable_memoryprovider(`vtable`: UniffiVTableCallbackInterfaceMemoryProvider,
+    ): Unit
     fun uniffi_native_agent_ffi_fn_init_callback_vtable_nativeeventcallback(`vtable`: UniffiVTableCallbackInterfaceNativeEventCallback,
     ): Unit
     fun uniffi_native_agent_ffi_fn_init_callback_vtable_nativenotifier(`vtable`: UniffiVTableCallbackInterfaceNativeNotifier,
@@ -1139,6 +1195,8 @@ internal interface UniffiLib : Library {
     ): Short
     fun uniffi_native_agent_ffi_checksum_method_nativeagenthandle_set_heartbeat_config(
     ): Short
+    fun uniffi_native_agent_ffi_checksum_method_nativeagenthandle_set_memory_provider(
+    ): Short
     fun uniffi_native_agent_ffi_checksum_method_nativeagenthandle_set_notifier(
     ): Short
     fun uniffi_native_agent_ffi_checksum_method_nativeagenthandle_set_scheduler_config(
@@ -1155,6 +1213,16 @@ internal interface UniffiLib : Library {
     ): Short
     fun uniffi_native_agent_ffi_checksum_constructor_nativeagenthandle_new(
     ): Short
+    fun uniffi_native_agent_ffi_checksum_method_memoryprovider_store(
+    ): Short
+    fun uniffi_native_agent_ffi_checksum_method_memoryprovider_recall(
+    ): Short
+    fun uniffi_native_agent_ffi_checksum_method_memoryprovider_forget(
+    ): Short
+    fun uniffi_native_agent_ffi_checksum_method_memoryprovider_search(
+    ): Short
+    fun uniffi_native_agent_ffi_checksum_method_memoryprovider_list(
+    ): Short
     fun uniffi_native_agent_ffi_checksum_method_nativeeventcallback_on_event(
     ): Short
     fun uniffi_native_agent_ffi_checksum_method_nativenotifier_send_notification(
@@ -1281,6 +1349,9 @@ private fun uniffiCheckApiChecksums(lib: UniffiLib) {
     if (lib.uniffi_native_agent_ffi_checksum_method_nativeagenthandle_set_heartbeat_config() != 33968.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
+    if (lib.uniffi_native_agent_ffi_checksum_method_nativeagenthandle_set_memory_provider() != 23171.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if (lib.uniffi_native_agent_ffi_checksum_method_nativeagenthandle_set_notifier() != 58795.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -1305,6 +1376,21 @@ private fun uniffiCheckApiChecksums(lib: UniffiLib) {
     if (lib.uniffi_native_agent_ffi_checksum_constructor_nativeagenthandle_new() != 18383.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
+    if (lib.uniffi_native_agent_ffi_checksum_method_memoryprovider_store() != 49136.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_native_agent_ffi_checksum_method_memoryprovider_recall() != 3170.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_native_agent_ffi_checksum_method_memoryprovider_forget() != 43231.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_native_agent_ffi_checksum_method_memoryprovider_search() != 19100.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_native_agent_ffi_checksum_method_memoryprovider_list() != 46802.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if (lib.uniffi_native_agent_ffi_checksum_method_nativeeventcallback_on_event() != 29742.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -1815,6 +1901,8 @@ public interface NativeAgentHandleInterface {
      */
     fun `setHeartbeatConfig`(`configJson`: kotlin.String)
     
+    fun `setMemoryProvider`(`provider`: MemoryProvider)
+    
     fun `setNotifier`(`notifier`: NativeNotifier)
     
     /**
@@ -2455,6 +2543,18 @@ open class NativeAgentHandle: Disposable, AutoCloseable, NativeAgentHandleInterf
     
 
     
+    @Throws(NativeAgentException::class)override fun `setMemoryProvider`(`provider`: MemoryProvider)
+        = 
+    callWithPointer {
+    uniffiRustCallWithError(NativeAgentException) { _status ->
+    UniffiLib.INSTANCE.uniffi_native_agent_ffi_fn_method_nativeagenthandle_set_memory_provider(
+        it, FfiConverterTypeMemoryProvider.lower(`provider`),_status)
+}
+    }
+    
+    
+
+    
     @Throws(NativeAgentException::class)override fun `setNotifier`(`notifier`: NativeNotifier)
         = 
     callWithPointer {
@@ -3043,16 +3143,20 @@ public object FfiConverterTypeNativeAgentError : FfiConverterRustBuffer<NativeAg
 
 
 /**
- * Callback interface for events from the native agent.
+ * Callback interface for memory operations (LanceDB or any vector store).
+ * Implemented by Kotlin/Swift, which bridges to the actual memory backend.
  */
-public interface NativeEventCallback {
+public interface MemoryProvider {
     
-    /**
-     * Called when the agent emits an event.
-     * `event_type`: text_delta, tool_use, tool_result, agent.completed, agent.error, etc.
-     * `payload_json`: JSON-encoded event data.
-     */
-    fun `onEvent`(`eventType`: kotlin.String, `payloadJson`: kotlin.String)
+    fun `store`(`key`: kotlin.String, `text`: kotlin.String, `metadataJson`: kotlin.String?): kotlin.String
+    
+    fun `recall`(`query`: kotlin.String, `limit`: kotlin.UInt): kotlin.String
+    
+    fun `forget`(`key`: kotlin.String): kotlin.String
+    
+    fun `search`(`query`: kotlin.String, `maxResults`: kotlin.UInt): kotlin.String
+    
+    fun `list`(`prefix`: kotlin.String?, `limit`: kotlin.UInt?): kotlin.String
     
     companion object
 }
@@ -3090,6 +3194,124 @@ public abstract class FfiConverterCallbackInterface<CallbackInterface: Any>: Ffi
     }
 }
 
+// Put the implementation in an object so we don't pollute the top-level namespace
+internal object uniffiCallbackInterfaceMemoryProvider {
+    internal object `store`: UniffiCallbackInterfaceMemoryProviderMethod0 {
+        override fun callback(`uniffiHandle`: Long,`key`: RustBuffer.ByValue,`text`: RustBuffer.ByValue,`metadataJson`: RustBuffer.ByValue,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,) {
+            val uniffiObj = FfiConverterTypeMemoryProvider.handleMap.get(uniffiHandle)
+            val makeCall = { ->
+                uniffiObj.`store`(
+                    FfiConverterString.lift(`key`),
+                    FfiConverterString.lift(`text`),
+                    FfiConverterOptionalString.lift(`metadataJson`),
+                )
+            }
+            val writeReturn = { value: kotlin.String -> uniffiOutReturn.setValue(FfiConverterString.lower(value)) }
+            uniffiTraitInterfaceCall(uniffiCallStatus, makeCall, writeReturn)
+        }
+    }
+    internal object `recall`: UniffiCallbackInterfaceMemoryProviderMethod1 {
+        override fun callback(`uniffiHandle`: Long,`query`: RustBuffer.ByValue,`limit`: Int,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,) {
+            val uniffiObj = FfiConverterTypeMemoryProvider.handleMap.get(uniffiHandle)
+            val makeCall = { ->
+                uniffiObj.`recall`(
+                    FfiConverterString.lift(`query`),
+                    FfiConverterUInt.lift(`limit`),
+                )
+            }
+            val writeReturn = { value: kotlin.String -> uniffiOutReturn.setValue(FfiConverterString.lower(value)) }
+            uniffiTraitInterfaceCall(uniffiCallStatus, makeCall, writeReturn)
+        }
+    }
+    internal object `forget`: UniffiCallbackInterfaceMemoryProviderMethod2 {
+        override fun callback(`uniffiHandle`: Long,`key`: RustBuffer.ByValue,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,) {
+            val uniffiObj = FfiConverterTypeMemoryProvider.handleMap.get(uniffiHandle)
+            val makeCall = { ->
+                uniffiObj.`forget`(
+                    FfiConverterString.lift(`key`),
+                )
+            }
+            val writeReturn = { value: kotlin.String -> uniffiOutReturn.setValue(FfiConverterString.lower(value)) }
+            uniffiTraitInterfaceCall(uniffiCallStatus, makeCall, writeReturn)
+        }
+    }
+    internal object `search`: UniffiCallbackInterfaceMemoryProviderMethod3 {
+        override fun callback(`uniffiHandle`: Long,`query`: RustBuffer.ByValue,`maxResults`: Int,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,) {
+            val uniffiObj = FfiConverterTypeMemoryProvider.handleMap.get(uniffiHandle)
+            val makeCall = { ->
+                uniffiObj.`search`(
+                    FfiConverterString.lift(`query`),
+                    FfiConverterUInt.lift(`maxResults`),
+                )
+            }
+            val writeReturn = { value: kotlin.String -> uniffiOutReturn.setValue(FfiConverterString.lower(value)) }
+            uniffiTraitInterfaceCall(uniffiCallStatus, makeCall, writeReturn)
+        }
+    }
+    internal object `list`: UniffiCallbackInterfaceMemoryProviderMethod4 {
+        override fun callback(`uniffiHandle`: Long,`prefix`: RustBuffer.ByValue,`limit`: RustBuffer.ByValue,`uniffiOutReturn`: RustBuffer,uniffiCallStatus: UniffiRustCallStatus,) {
+            val uniffiObj = FfiConverterTypeMemoryProvider.handleMap.get(uniffiHandle)
+            val makeCall = { ->
+                uniffiObj.`list`(
+                    FfiConverterOptionalString.lift(`prefix`),
+                    FfiConverterOptionalUInt.lift(`limit`),
+                )
+            }
+            val writeReturn = { value: kotlin.String -> uniffiOutReturn.setValue(FfiConverterString.lower(value)) }
+            uniffiTraitInterfaceCall(uniffiCallStatus, makeCall, writeReturn)
+        }
+    }
+
+    internal object uniffiFree: UniffiCallbackInterfaceFree {
+        override fun callback(handle: Long) {
+            FfiConverterTypeMemoryProvider.handleMap.remove(handle)
+        }
+    }
+
+    internal var vtable = UniffiVTableCallbackInterfaceMemoryProvider.UniffiByValue(
+        `store`,
+        `recall`,
+        `forget`,
+        `search`,
+        `list`,
+        uniffiFree,
+    )
+
+    // Registers the foreign callback with the Rust side.
+    // This method is generated for each callback interface.
+    internal fun register(lib: UniffiLib) {
+        lib.uniffi_native_agent_ffi_fn_init_callback_vtable_memoryprovider(vtable)
+    }
+}
+
+/**
+ * The ffiConverter which transforms the Callbacks in to handles to pass to Rust.
+ *
+ * @suppress
+ */
+public object FfiConverterTypeMemoryProvider: FfiConverterCallbackInterface<MemoryProvider>()
+
+
+
+
+
+/**
+ * Callback interface for events from the native agent.
+ */
+public interface NativeEventCallback {
+    
+    /**
+     * Called when the agent emits an event.
+     * `event_type`: text_delta, tool_use, tool_result, agent.completed, agent.error, etc.
+     * `payload_json`: JSON-encoded event data.
+     */
+    fun `onEvent`(`eventType`: kotlin.String, `payloadJson`: kotlin.String)
+    
+    companion object
+}
+
+
+
 // Put the implementation in an object so we don't pollute the top-level namespace
 internal object uniffiCallbackInterfaceNativeEventCallback {
     internal object `onEvent`: UniffiCallbackInterfaceNativeEventCallbackMethod0 {

package/ios/Frameworks/NativeAgentFFI.xcframework/ios-arm64/Headers/{native_agent_ffiFFI → native_agent_ffi}/module.modulemap

@@ -1,4 +1,4 @@
 module native_agent_ffiFFI {
     header "native_agent_ffiFFI.h"
     export *
-}
+}