capacitor-native-agent 0.3.5 → 0.3.7

package/ios/Sources/NativeAgentPlugin/LanceDBBridge.swift

@@ -0,0 +1,70 @@
+import Foundation
+
+#if canImport(CapacitorLanceDB)
+import CapacitorLanceDB
+#elseif canImport(CapacitorLancedb)
+import CapacitorLancedb
+#elseif canImport(LanceDBPlugin)
+import LanceDBPlugin
+#endif
+
+#if canImport(CapacitorLanceDB) || canImport(CapacitorLancedb) || canImport(LanceDBPlugin)
+final class LanceDBBridge {
+    static let shared = LanceDBBridge()
+    static let embeddingDim: Int32 = 1536
+
+    private let lock = NSLock()
+    private var handle: LanceDbHandle?
+
+    func getOrCreateHandle() -> LanceDbHandle? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if let handle {
+            return handle
+        }
+
+        let dbPath = FileManager.default
+            .urls(for: .libraryDirectory, in: .userDomainMask)
+            .first!
+            .appendingPathComponent("lancedb-memories")
+            .path
+
+        try? FileManager.default.createDirectory(
+            atPath: dbPath,
+            withIntermediateDirectories: true,
+            attributes: nil
+        )
+
+        let opened = try? Self.awaitResult {
+            try await LanceDbHandle.open(dbPath: dbPath, embeddingDim: Self.embeddingDim)
+        }
+        handle = opened
+        return opened
+    }
+
+    static func awaitResult<T>(_ operation: @escaping () async throws -> T) throws -> T {
+        let semaphore = DispatchSemaphore(value: 0)
+        let resultLock = NSLock()
+        var outcome: Result<T, Error>?
+
+        Task.detached {
+            let result: Result<T, Error>
+            do {
+                result = .success(try await operation())
+            } catch {
+                result = .failure(error)
+            }
+            resultLock.lock()
+            outcome = result
+            resultLock.unlock()
+            semaphore.signal()
+        }
+
+        semaphore.wait()
+        resultLock.lock()
+        defer { resultLock.unlock() }
+        return try outcome!.get()
+    }
+}
+#endif

package/ios/Sources/NativeAgentPlugin/MemoryProviderImpl.swift

@@ -0,0 +1,206 @@
+import Foundation
+
+#if canImport(CapacitorLanceDB) || canImport(CapacitorLancedb) || canImport(LanceDBPlugin)
+public final class MemoryProviderImpl: MemoryProvider {
+    public static func makeIfAvailable() -> MemoryProvider? {
+        guard LanceDBBridge.shared.getOrCreateHandle() != nil else {
+            return nil
+        }
+        return MemoryProviderImpl()
+    }
+
+    public func store(key: String, text: String, metadataJson: String?) -> String {
+        guard let handle = LanceDBBridge.shared.getOrCreateHandle() else {
+            return errorJson("Memory provider not configured")
+        }
+
+        let resolvedKey = key.isEmpty
+            ? "mem-\(Int(Date().timeIntervalSince1970 * 1000))-\(UUID().uuidString.prefix(8))"
+            : key
+        let embedding = localHashEmbed(text, dim: Int(LanceDBBridge.embeddingDim))
+
+        do {
+            try LanceDBBridge.awaitResult {
+                try await handle.store(
+                    key: resolvedKey,
+                    agentId: Self.defaultAgentId,
+                    text: text,
+                    embedding: embedding,
+                    metadata: metadataJson
+                )
+            }
+            return jsonString([
+                "success": true,
+                "key": resolvedKey,
+            ])
+        } catch {
+            return errorJson(error.localizedDescription)
+        }
+    }
+
+    public func recall(query: String, limit: UInt32) -> String {
+        guard let handle = LanceDBBridge.shared.getOrCreateHandle() else {
+            return errorJson("Memory provider not configured")
+        }
+
+        let embedding = localHashEmbed(query, dim: Int(LanceDBBridge.embeddingDim))
+
+        do {
+            let results = try LanceDBBridge.awaitResult {
+                try await handle.search(
+                    queryVector: embedding,
+                    limit: limit,
+                    filter: "agent_id = '\(Self.defaultAgentId)'"
+                )
+            }
+            return jsonString(results.map { result in
+                var object: [String: Any] = [
+                    "key": result.key,
+                    "text": result.text,
+                    "score": result.score,
+                ]
+                if let metadata = result.metadata {
+                    object["metadata"] = metadata
+                }
+                return object
+            })
+        } catch {
+            return errorJson(error.localizedDescription)
+        }
+    }
+
+    public func forget(key: String) -> String {
+        guard let handle = LanceDBBridge.shared.getOrCreateHandle() else {
+            return errorJson("Memory provider not configured")
+        }
+        guard !key.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            return errorJson("Provide query or key.")
+        }
+
+        do {
+            try LanceDBBridge.awaitResult {
+                try await handle.delete(key: key)
+            }
+            return jsonString([
+                "success": true,
+                "key": key,
+            ])
+        } catch {
+            return errorJson(error.localizedDescription)
+        }
+    }
+
+    public func search(query: String, maxResults: UInt32) -> String {
+        guard let handle = LanceDBBridge.shared.getOrCreateHandle() else {
+            return errorJson("Memory provider not configured")
+        }
+
+        let embedding = localHashEmbed(query, dim: Int(LanceDBBridge.embeddingDim))
+
+        do {
+            let results = try LanceDBBridge.awaitResult {
+                try await handle.search(
+                    queryVector: embedding,
+                    limit: maxResults,
+                    filter: "agent_id = '\(Self.defaultAgentId)'"
+                )
+            }
+            return jsonString(results.map { result in
+                var object: [String: Any] = [
+                    "key": result.key,
+                    "text": result.text,
+                    "score": result.score,
+                ]
+                if let metadata = result.metadata {
+                    object["metadata"] = metadata
+                }
+                return object
+            })
+        } catch {
+            return errorJson(error.localizedDescription)
+        }
+    }
+
+    public func list(prefix: String?, limit: UInt32?) -> String {
+        guard let handle = LanceDBBridge.shared.getOrCreateHandle() else {
+            return errorJson("Memory provider not configured")
+        }
+
+        do {
+            let keys = try LanceDBBridge.awaitResult {
+                try await handle.list(prefix: prefix, limit: limit)
+            }
+            return jsonString(keys)
+        } catch {
+            return errorJson(error.localizedDescription)
+        }
+    }
+
+    private static let defaultAgentId = "main"
+    private static let whitespace = CharacterSet.whitespacesAndNewlines
+    private static let posixLocale = Locale(identifier: "en_US_POSIX")
+    private static let fnvOffset: UInt32 = 0x811c9dc5
+    private static let fnvPrime: UInt32 = 0x01000193
+    private static let goldenRatio: UInt32 = 2654435761
+    private static let mixConstant: UInt32 = 0x45d9f3b
+    private static let uintMaxDouble = Double(UInt32.max)
+
+    private func jsonString(_ value: Any) -> String {
+        guard JSONSerialization.isValidJSONObject(value),
+              let data = try? JSONSerialization.data(withJSONObject: value),
+              let string = String(data: data, encoding: .utf8) else {
+            return "{\"error\":\"Failed to encode JSON\"}"
+        }
+        return string
+    }
+
+    private func errorJson(_ message: String) -> String {
+        let escaped = message
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+        return "{\"error\":\"\(escaped)\"}"
+    }
+
+    private func fnv1a(_ text: String) -> UInt32 {
+        var hash = Self.fnvOffset
+        for scalar in text.unicodeScalars {
+            hash ^= UInt32(scalar.value)
+            hash = hash &* Self.fnvPrime
+        }
+        return hash
+    }
+
+    private func seededRandom(seed: UInt32, dim: Int) -> Float {
+        var h = seed ^ (UInt32(dim) &* Self.goldenRatio)
+        h = ((h >> 16) ^ h) &* Self.mixConstant
+        h = ((h >> 16) ^ h) &* Self.mixConstant
+        h = (h >> 16) ^ h
+        return Float((Double(h) / Self.uintMaxDouble) * 2.0 - 1.0)
+    }
+
+    private func localHashEmbed(_ text: String, dim: Int) -> [Float] {
+        let tokens = text
+            .lowercased(with: Self.posixLocale)
+            .components(separatedBy: Self.whitespace)
+            .filter { !$0.isEmpty }
+        var vector = Array(repeating: 0.0, count: dim)
+
+        for token in tokens {
+            let hash = fnv1a(token)
+            for index in 0..<dim {
+                vector[index] += Double(seededRandom(seed: hash, dim: index))
+            }
+        }
+
+        let norm = sqrt(vector.reduce(0.0) { $0 + ($1 * $1) })
+        let divisor = norm > 0 ? norm : 1
+        return vector.map { Float($0 / divisor) }
+    }
+}
+#else
+public final class MemoryProviderImpl {
+    public static func makeIfAvailable() -> MemoryProvider? {
+        nil
+    }
+}
+#endif

package/ios/Sources/NativeAgentPlugin/NativeAgentPlugin.swift

@@ -25,6 +25,7 @@ public class NativeAgentPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "deleteAuth", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "refreshToken", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getAuthStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "exchangeOAuthCode", returnType: CAPPluginReturnPromise),
         // Sessions
         CAPPluginMethod(name: "listSessions", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "loadSession", returnType: CAPPluginReturnPromise),
@@ -153,6 +154,9 @@ public class NativeAgentPlugin: CAPPlugin, CAPBridgedPlugin {
                 let h = try NativeAgentHandle(config: config)
                 try h.setEventCallback(callback: NativeAgentEventBridge(plugin: self))
                 try h.setNotifier(notifier: NativeNotifierImpl())
+                if let memoryProvider = MemoryProviderImpl.makeIfAvailable() {
+                    try h.setMemoryProvider(provider: memoryProvider)
+                }
                 try h.persistConfig()
                 self.handle = h
                 UserDefaults.standard.set(
@@ -357,6 +361,33 @@ public class NativeAgentPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
+    @objc func exchangeOAuthCode(_ call: CAPPluginCall) {
+        withHandle(call) { h in
+            guard let tokenUrl = call.getString("tokenUrl") else {
+                return call.reject("tokenUrl is required")
+            }
+            guard let bodyJson = call.getString("bodyJson") else {
+                return call.reject("bodyJson is required")
+            }
+            do {
+                let resultJson = try h.exchangeOauthCode(
+                    tokenUrl: tokenUrl,
+                    bodyJson: bodyJson,
+                    contentType: call.getString("contentType")
+                )
+                // Parse the JSON string into a dictionary and resolve
+                if let data = resultJson.data(using: .utf8),
+                   let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                    call.resolve(dict)
+                } else {
+                    call.resolve(["resultJson": resultJson])
+                }
+            } catch {
+                call.reject("exchangeOAuthCode failed: \(error.localizedDescription)")
+            }
+        }
+    }
+
     // ── Sessions ─────────────────────────────────────────────────────────────
 
     @objc func listSessions(_ call: CAPPluginCall) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-native-agent",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Native AI agent loop for Capacitor — runs LLM completions, tool execution, and cron jobs in native Rust, enabling background execution.",
   "main": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
@@ -56,7 +56,13 @@
     "url": "https://github.com/ArcadeLabsInc/capacitor-native-agent/issues"
   },
   "peerDependencies": {
-    "@capacitor/core": "^6.0.0 || ^7.0.0 || ^8.0.0"
+    "@capacitor/core": "^6.0.0 || ^7.0.0 || ^8.0.0",
+    "capacitor-lancedb": "^0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "capacitor-lancedb": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@capacitor/core": "^8.1.0",