@dvai-bridge/ios 4.0.0 → 4.0.2

package/ios/Sources/DVAIBridge/DVAIBridgeConfig.swift

@@ -1,86 +1,86 @@
-import Foundation
-
-public struct DVAIBridgeConfig: Sendable {
-    public enum CORSOrigin: Sendable {
-        case wildcard
-        case exact(String)
-        case allowlist([String])
-    }
-
-    public var backend: BackendKind
-    public var modelPath: String?
-    public var mmprojPath: String?
-    public var tokenizerPath: String?
-    public var gpuLayers: Int
-    public var contextSize: Int
-    public var threads: Int
-    public var embeddingMode: Bool
-    public var httpBasePort: Int
-    public var httpMaxPortAttempts: Int
-    public var corsOrigin: CORSOrigin
-    public var autoUnloadOnLowMemory: Bool
-    public var logLevel: String  // "silent" | "info" | "debug" — matches the Capacitor surface
-
-    public init(
-        backend: BackendKind = .auto,
-        modelPath: String? = nil,
-        mmprojPath: String? = nil,
-        tokenizerPath: String? = nil,
-        gpuLayers: Int = 99,
-        contextSize: Int = 2048,
-        threads: Int = 4,
-        embeddingMode: Bool = false,
-        httpBasePort: Int = 38883,
-        httpMaxPortAttempts: Int = 16,
-        corsOrigin: CORSOrigin = .wildcard,
-        autoUnloadOnLowMemory: Bool = false,
-        logLevel: String = "info"
-    ) {
-        self.backend = backend
-        self.modelPath = modelPath
-        self.mmprojPath = mmprojPath
-        self.tokenizerPath = tokenizerPath
-        self.gpuLayers = gpuLayers
-        self.contextSize = contextSize
-        self.threads = threads
-        self.embeddingMode = embeddingMode
-        self.httpBasePort = httpBasePort
-        self.httpMaxPortAttempts = httpMaxPortAttempts
-        self.corsOrigin = corsOrigin
-        self.autoUnloadOnLowMemory = autoUnloadOnLowMemory
-        self.logLevel = logLevel
-    }
-
-    /// v3.2 — copy with `httpBasePort` overridden. Used by the
-    /// OffloadProxy lifecycle to push the backend off the user-facing
-    /// port (proxy claims `httpBasePort`, backend gets `httpBasePort + 100`).
-    public func with(httpBasePort newPort: Int) -> DVAIBridgeConfig {
-        var copy = self
-        copy.httpBasePort = newPort
-        return copy
-    }
-
-    /// Translate this config into the `[String: Any]` shape the underlying
-    /// core PluginStates expect (matches the Capacitor JSObject shape).
-    internal func toCoreOpts() -> [String: Any] {
-        var opts: [String: Any] = [
-            "gpuLayers": gpuLayers,
-            "contextSize": contextSize,
-            "threads": threads,
-            "embeddingMode": embeddingMode,
-            "httpBasePort": httpBasePort,
-            "httpMaxPortAttempts": httpMaxPortAttempts,
-            "autoUnloadOnLowMemory": autoUnloadOnLowMemory,
-            "logLevel": logLevel,
-        ]
-        if let modelPath { opts["modelPath"] = modelPath }
-        if let mmprojPath { opts["mmprojPath"] = mmprojPath }
-        if let tokenizerPath { opts["tokenizerPath"] = tokenizerPath }
-        switch corsOrigin {
-        case .wildcard: opts["corsOrigin"] = "*"
-        case .exact(let s): opts["corsOrigin"] = s
-        case .allowlist(let xs): opts["corsOrigin"] = xs
-        }
-        return opts
-    }
-}
+import Foundation
+
+public struct DVAIBridgeConfig: Sendable {
+    public enum CORSOrigin: Sendable {
+        case wildcard
+        case exact(String)
+        case allowlist([String])
+    }
+
+    public var backend: BackendKind
+    public var modelPath: String?
+    public var mmprojPath: String?
+    public var tokenizerPath: String?
+    public var gpuLayers: Int
+    public var contextSize: Int
+    public var threads: Int
+    public var embeddingMode: Bool
+    public var httpBasePort: Int
+    public var httpMaxPortAttempts: Int
+    public var corsOrigin: CORSOrigin
+    public var autoUnloadOnLowMemory: Bool
+    public var logLevel: String  // "silent" | "info" | "debug" — matches the Capacitor surface
+
+    public init(
+        backend: BackendKind = .auto,
+        modelPath: String? = nil,
+        mmprojPath: String? = nil,
+        tokenizerPath: String? = nil,
+        gpuLayers: Int = 99,
+        contextSize: Int = 2048,
+        threads: Int = 4,
+        embeddingMode: Bool = false,
+        httpBasePort: Int = 38883,
+        httpMaxPortAttempts: Int = 16,
+        corsOrigin: CORSOrigin = .wildcard,
+        autoUnloadOnLowMemory: Bool = false,
+        logLevel: String = "info"
+    ) {
+        self.backend = backend
+        self.modelPath = modelPath
+        self.mmprojPath = mmprojPath
+        self.tokenizerPath = tokenizerPath
+        self.gpuLayers = gpuLayers
+        self.contextSize = contextSize
+        self.threads = threads
+        self.embeddingMode = embeddingMode
+        self.httpBasePort = httpBasePort
+        self.httpMaxPortAttempts = httpMaxPortAttempts
+        self.corsOrigin = corsOrigin
+        self.autoUnloadOnLowMemory = autoUnloadOnLowMemory
+        self.logLevel = logLevel
+    }
+
+    /// v3.2 — copy with `httpBasePort` overridden. Used by the
+    /// OffloadProxy lifecycle to push the backend off the user-facing
+    /// port (proxy claims `httpBasePort`, backend gets `httpBasePort + 100`).
+    public func with(httpBasePort newPort: Int) -> DVAIBridgeConfig {
+        var copy = self
+        copy.httpBasePort = newPort
+        return copy
+    }
+
+    /// Translate this config into the `[String: Any]` shape the underlying
+    /// core PluginStates expect (matches the Capacitor JSObject shape).
+    internal func toCoreOpts() -> [String: Any] {
+        var opts: [String: Any] = [
+            "gpuLayers": gpuLayers,
+            "contextSize": contextSize,
+            "threads": threads,
+            "embeddingMode": embeddingMode,
+            "httpBasePort": httpBasePort,
+            "httpMaxPortAttempts": httpMaxPortAttempts,
+            "autoUnloadOnLowMemory": autoUnloadOnLowMemory,
+            "logLevel": logLevel,
+        ]
+        if let modelPath { opts["modelPath"] = modelPath }
+        if let mmprojPath { opts["mmprojPath"] = mmprojPath }
+        if let tokenizerPath { opts["tokenizerPath"] = tokenizerPath }
+        switch corsOrigin {
+        case .wildcard: opts["corsOrigin"] = "*"
+        case .exact(let s): opts["corsOrigin"] = s
+        case .allowlist(let xs): opts["corsOrigin"] = xs
+        }
+        return opts
+    }
+}

package/ios/Sources/DVAIBridge/DVAIBridgeError.swift

@@ -1,33 +1,33 @@
-import Foundation
-
-public enum DVAIBridgeError: Error, LocalizedError, Sendable {
-    case notStarted
-    case alreadyStarted(currentBackend: BackendKind, baseUrl: String)
-    case configurationInvalid(reason: String)
-    case backendUnavailable(BackendKind, reason: String)
-    case modelLoadFailed(reason: String)
-    case downloadFailed(reason: String)
-    case checksumMismatch
-    case backendError(underlying: String)
-
-    public var errorDescription: String? {
-        switch self {
-        case .notStarted:
-            return "DVAIBridge has not been started. Call DVAIBridge.shared.start(...) first."
-        case .alreadyStarted(let backend, let baseUrl):
-            return "DVAIBridge is already running with backend \(backend) at \(baseUrl). Call stop() before starting a new session."
-        case .configurationInvalid(let reason):
-            return "Configuration invalid: \(reason)"
-        case .backendUnavailable(let backend, let reason):
-            return "Backend \(backend) is unavailable on this device: \(reason)"
-        case .modelLoadFailed(let reason):
-            return "Model load failed: \(reason)"
-        case .downloadFailed(let reason):
-            return "Download failed: \(reason)"
-        case .checksumMismatch:
-            return "Downloaded file's SHA-256 didn't match the expected value. The file has been deleted from the cache."
-        case .backendError(let msg):
-            return "Backend error: \(msg)"
-        }
-    }
-}
+import Foundation
+
+public enum DVAIBridgeError: Error, LocalizedError, Sendable {
+    case notStarted
+    case alreadyStarted(currentBackend: BackendKind, baseUrl: String)
+    case configurationInvalid(reason: String)
+    case backendUnavailable(BackendKind, reason: String)
+    case modelLoadFailed(reason: String)
+    case downloadFailed(reason: String)
+    case checksumMismatch
+    case backendError(underlying: String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .notStarted:
+            return "DVAIBridge has not been started. Call DVAIBridge.shared.start(...) first."
+        case .alreadyStarted(let backend, let baseUrl):
+            return "DVAIBridge is already running with backend \(backend) at \(baseUrl). Call stop() before starting a new session."
+        case .configurationInvalid(let reason):
+            return "Configuration invalid: \(reason)"
+        case .backendUnavailable(let backend, let reason):
+            return "Backend \(backend) is unavailable on this device: \(reason)"
+        case .modelLoadFailed(let reason):
+            return "Model load failed: \(reason)"
+        case .downloadFailed(let reason):
+            return "Download failed: \(reason)"
+        case .checksumMismatch:
+            return "Downloaded file's SHA-256 didn't match the expected value. The file has been deleted from the cache."
+        case .backendError(let msg):
+            return "Backend error: \(msg)"
+        }
+    }
+}

package/ios/Sources/DVAIBridge/Internal/BackendSelector.swift

@@ -1,59 +1,59 @@
-import Foundation
-
-internal enum BackendSelector {
-    /// Resolve `.auto` to a concrete backend; pass-through for explicit choices.
-    /// - Throws `DVAIBridgeError.configurationInvalid` if `.auto` can't decide.
-    static func resolve(_ kind: BackendKind, config: DVAIBridgeConfig) throws -> BackendKind {
-        if kind != .auto { return kind }
-
-        // 1. modelPath ending in .gguf → .llama
-        if let path = config.modelPath, path.hasSuffix(".gguf") {
-            return .llama
-        }
-
-        // 2. modelPath ending in .mlmodelc / .mlpackage → .coreml
-        if let path = config.modelPath,
-           path.hasSuffix(".mlmodelc") || path.hasSuffix(".mlpackage") {
-            return .coreml
-        }
-
-        // 3. modelPath ending in .task / .litertlm → no iOS backend supports
-        //    those; fall through to error
-        if let path = config.modelPath,
-           path.hasSuffix(".task") || path.hasSuffix(".litertlm") {
-            throw DVAIBridgeError.configurationInvalid(reason:
-                "Model file '\(path)' is a MediaPipe / LiteRT-LM format. " +
-                "Use it via the Android SDK; iOS supports llama.cpp (.gguf), " +
-                "Apple Foundation Models (no file), and CoreML (.mlmodelc / .mlpackage).")
-        }
-
-        // 4. No modelPath + iOS 26+ → .foundation
-        if config.modelPath == nil {
-            if #available(iOS 26.0, macOS 26.0, *) {
-                return .foundation
-            }
-            throw DVAIBridgeError.configurationInvalid(reason:
-                "auto backend requires either modelPath (for .llama / .coreml) " +
-                "or iOS 26+ (for .foundation). Set DVAIBridgeConfig.backend explicitly.")
-        }
-
-        // 5. modelPath looks like a HuggingFace id ("<owner>/<repo>" with no
-        //    file extension) → likely MLX. Don't auto-resolve here because
-        //    not every HF id is MLX (could be GGUF in a HF repo etc.) and
-        //    .mlx requires Apple Silicon at runtime. Provide a clear hint.
-        if let path = config.modelPath,
-           path.contains("/"),
-           !path.contains(".") {
-            throw DVAIBridgeError.configurationInvalid(reason:
-                "modelPath '\(path)' looks like a HuggingFace identifier. " +
-                "If this is an MLX-converted checkpoint (e.g. 'mlx-community/...'), " +
-                "set DVAIBridgeConfig.backend = .mlx explicitly — `.auto` won't " +
-                "infer MLX because not every HF id is an MLX checkpoint.")
-        }
-
-        // 6. Unknown extension
-        throw DVAIBridgeError.configurationInvalid(reason:
-            "auto backend can't infer from modelPath '\(config.modelPath ?? "<nil>")'. " +
-            "Set DVAIBridgeConfig.backend = .llama / .foundation / .coreml / .mlx explicitly.")
-    }
-}
+import Foundation
+
+internal enum BackendSelector {
+    /// Resolve `.auto` to a concrete backend; pass-through for explicit choices.
+    /// - Throws `DVAIBridgeError.configurationInvalid` if `.auto` can't decide.
+    static func resolve(_ kind: BackendKind, config: DVAIBridgeConfig) throws -> BackendKind {
+        if kind != .auto { return kind }
+
+        // 1. modelPath ending in .gguf → .llama
+        if let path = config.modelPath, path.hasSuffix(".gguf") {
+            return .llama
+        }
+
+        // 2. modelPath ending in .mlmodelc / .mlpackage → .coreml
+        if let path = config.modelPath,
+           path.hasSuffix(".mlmodelc") || path.hasSuffix(".mlpackage") {
+            return .coreml
+        }
+
+        // 3. modelPath ending in .task / .litertlm → no iOS backend supports
+        //    those; fall through to error
+        if let path = config.modelPath,
+           path.hasSuffix(".task") || path.hasSuffix(".litertlm") {
+            throw DVAIBridgeError.configurationInvalid(reason:
+                "Model file '\(path)' is a MediaPipe / LiteRT-LM format. " +
+                "Use it via the Android SDK; iOS supports llama.cpp (.gguf), " +
+                "Apple Foundation Models (no file), and CoreML (.mlmodelc / .mlpackage).")
+        }
+
+        // 4. No modelPath + iOS 26+ → .foundation
+        if config.modelPath == nil {
+            if #available(iOS 26.0, macOS 26.0, *) {
+                return .foundation
+            }
+            throw DVAIBridgeError.configurationInvalid(reason:
+                "auto backend requires either modelPath (for .llama / .coreml) " +
+                "or iOS 26+ (for .foundation). Set DVAIBridgeConfig.backend explicitly.")
+        }
+
+        // 5. modelPath looks like a HuggingFace id ("<owner>/<repo>" with no
+        //    file extension) → likely MLX. Don't auto-resolve here because
+        //    not every HF id is MLX (could be GGUF in a HF repo etc.) and
+        //    .mlx requires Apple Silicon at runtime. Provide a clear hint.
+        if let path = config.modelPath,
+           path.contains("/"),
+           !path.contains(".") {
+            throw DVAIBridgeError.configurationInvalid(reason:
+                "modelPath '\(path)' looks like a HuggingFace identifier. " +
+                "If this is an MLX-converted checkpoint (e.g. 'mlx-community/...'), " +
+                "set DVAIBridgeConfig.backend = .mlx explicitly — `.auto` won't " +
+                "infer MLX because not every HF id is an MLX checkpoint.")
+        }
+
+        // 6. Unknown extension
+        throw DVAIBridgeError.configurationInvalid(reason:
+            "auto backend can't infer from modelPath '\(config.modelPath ?? "<nil>")'. " +
+            "Set DVAIBridgeConfig.backend = .llama / .foundation / .coreml / .mlx explicitly.")
+    }
+}

package/ios/Sources/DVAIBridge/Internal/ProgressBroadcaster.swift

@@ -1,84 +1,84 @@
-import Foundation
-import Combine
-
-/// Internal event broadcaster. Backs three public observation surfaces:
-/// `progressPublisher` (Combine), `progressStream` (AsyncStream), and
-/// `addProgressListener(_:)` (callback). All three observe the same source.
-internal final class ProgressBroadcaster: @unchecked Sendable {
-    // Combine
-    private let subject = PassthroughSubject<ProgressEvent, Never>()
-    var publisher: AnyPublisher<ProgressEvent, Never> { subject.eraseToAnyPublisher() }
-
-    // AsyncStream — one continuation per consumer
-    private let lock = NSLock()
-    private var continuations: [UUID: AsyncStream<ProgressEvent>.Continuation] = [:]
-
-    // Callback — one entry per addProgressListener call
-    private var callbacks: [UUID: @Sendable (ProgressEvent) -> Void] = [:]
-
-    func emit(_ event: ProgressEvent) {
-        subject.send(event)
-
-        lock.lock()
-        let conts = continuations.values
-        let cbs = Array(callbacks.values)
-        lock.unlock()
-
-        for cont in conts { cont.yield(event) }
-        for cb in cbs { cb(event) }
-    }
-
-    func makeStream() -> AsyncStream<ProgressEvent> {
-        let id = UUID()
-        return AsyncStream { continuation in
-            lock.lock()
-            continuations[id] = continuation
-            lock.unlock()
-
-            continuation.onTermination = { [weak self] _ in
-                self?.lock.lock()
-                self?.continuations.removeValue(forKey: id)
-                self?.lock.unlock()
-            }
-        }
-    }
-
-    @discardableResult
-    func addCallback(_ cb: @escaping @Sendable (ProgressEvent) -> Void) -> CancellationToken {
-        let id = UUID()
-        lock.lock()
-        callbacks[id] = cb
-        lock.unlock()
-
-        return CancellationToken { [weak self] in
-            self?.lock.lock()
-            self?.callbacks.removeValue(forKey: id)
-            self?.lock.unlock()
-        }
-    }
-}
-
-/// Caller-held token returned by `addProgressListener(_:)`. Drop or call
-/// `.cancel()` to stop receiving events.
-public final class CancellationToken: @unchecked Sendable {
-    private let cancelClosure: @Sendable () -> Void
-    private var cancelled = false
-    private let lock = NSLock()
-
-    internal init(cancel: @escaping @Sendable () -> Void) {
-        self.cancelClosure = cancel
-    }
-
-    public func cancel() {
-        lock.lock()
-        defer { lock.unlock() }
-        if !cancelled {
-            cancelled = true
-            cancelClosure()
-        }
-    }
-
-    deinit {
-        cancel()
-    }
-}
+import Foundation
+import Combine
+
+/// Internal event broadcaster. Backs three public observation surfaces:
+/// `progressPublisher` (Combine), `progressStream` (AsyncStream), and
+/// `addProgressListener(_:)` (callback). All three observe the same source.
+internal final class ProgressBroadcaster: @unchecked Sendable {
+    // Combine
+    private let subject = PassthroughSubject<ProgressEvent, Never>()
+    var publisher: AnyPublisher<ProgressEvent, Never> { subject.eraseToAnyPublisher() }
+
+    // AsyncStream — one continuation per consumer
+    private let lock = NSLock()
+    private var continuations: [UUID: AsyncStream<ProgressEvent>.Continuation] = [:]
+
+    // Callback — one entry per addProgressListener call
+    private var callbacks: [UUID: @Sendable (ProgressEvent) -> Void] = [:]
+
+    func emit(_ event: ProgressEvent) {
+        subject.send(event)
+
+        lock.lock()
+        let conts = continuations.values
+        let cbs = Array(callbacks.values)
+        lock.unlock()
+
+        for cont in conts { cont.yield(event) }
+        for cb in cbs { cb(event) }
+    }
+
+    func makeStream() -> AsyncStream<ProgressEvent> {
+        let id = UUID()
+        return AsyncStream { continuation in
+            lock.lock()
+            continuations[id] = continuation
+            lock.unlock()
+
+            continuation.onTermination = { [weak self] _ in
+                self?.lock.lock()
+                self?.continuations.removeValue(forKey: id)
+                self?.lock.unlock()
+            }
+        }
+    }
+
+    @discardableResult
+    func addCallback(_ cb: @escaping @Sendable (ProgressEvent) -> Void) -> CancellationToken {
+        let id = UUID()
+        lock.lock()
+        callbacks[id] = cb
+        lock.unlock()
+
+        return CancellationToken { [weak self] in
+            self?.lock.lock()
+            self?.callbacks.removeValue(forKey: id)
+            self?.lock.unlock()
+        }
+    }
+}
+
+/// Caller-held token returned by `addProgressListener(_:)`. Drop or call
+/// `.cancel()` to stop receiving events.
+public final class CancellationToken: @unchecked Sendable {
+    private let cancelClosure: @Sendable () -> Void
+    private var cancelled = false
+    private let lock = NSLock()
+
+    internal init(cancel: @escaping @Sendable () -> Void) {
+        self.cancelClosure = cancel
+    }
+
+    public func cancel() {
+        lock.lock()
+        defer { lock.unlock() }
+        if !cancelled {
+            cancelled = true
+            cancelClosure()
+        }
+    }
+
+    deinit {
+        cancel()
+    }
+}