@dvai-bridge/ios 4.0.0 → 4.0.1

package/ios/Sources/DVAICoreMLCore/Internal/CoreMLGenerator.swift

@@ -1,108 +1,108 @@
-import Foundation
-import CoreML
-
-/// Orchestrates `CoreMLEngine` + `CoreMLTokenizer` + `CoreMLSampler` to
-/// produce text from a prompt via autoregressive decoding.
-///
-/// CoreML prediction note (iOS 18):
-///   `MLModel.prediction(from:using:options:)` is synchronous. We wrap the
-///   decode loop in a `Task.detached` (in `generateStream`) or simply call
-///   `runStep` directly in the async context for `generate`. Since `runStep`
-///   is not itself `async`, calling it in an `async` function does NOT suspend
-///   — it runs inline on the current executor. For long-running decodes the
-///   caller should call `generate` / `generateStream` from a background Task
-///   to avoid blocking the main actor.
-@available(iOS 18.0, macOS 15.0, *)
-internal struct CoreMLGenerator: @unchecked Sendable {
-    let engine: CoreMLEngine
-    let tokenizer: CoreMLTokenizer
-    let sampler: CoreMLSampler
-    let maxNewTokens: Int
-
-    /// Buffered generation. Runs the full decode loop and returns the decoded text.
-    func generate(promptTokens: [Int]) async throws -> String {
-        return try await Task.detached(priority: .userInitiated) {
-            guard !promptTokens.isEmpty else {
-                throw CoreMLBackendError.generationFailed(reason: "prompt tokens are empty")
-            }
-
-            var generated: [Int] = []
-            let state = self.engine.makeConversationState()
-
-            // Prefill + decode unified: each runStep returns logits for the
-            // *next* token at position (kvPos+1). After feeding all prompt
-            // tokens, the last logits give us our first generated token.
-            // (Previous iteration of this code re-fed promptTokens.last as a
-            // separate step, which double-counted that token in the KV
-            // cache.)
-            var kvPos = 0
-            var lastLogits: MLMultiArray = try self.engine.runStep(
-                token: promptTokens[0], kvCachePosition: 0, state: state
-            )
-            kvPos = 1
-            for token in promptTokens.dropFirst() {
-                lastLogits = try self.engine.runStep(
-                    token: token, kvCachePosition: kvPos, state: state
-                )
-                kvPos += 1
-            }
-
-            var nextToken = self.sampler.sample(logits: lastLogits)
-
-            for _ in 0 ..< self.maxNewTokens {
-                if nextToken == self.engine.eosTokenId { break }
-                generated.append(nextToken)
-                lastLogits = try self.engine.runStep(
-                    token: nextToken, kvCachePosition: kvPos, state: state
-                )
-                kvPos += 1
-                nextToken = self.sampler.sample(logits: lastLogits)
-            }
-
-            return self.tokenizer.decode(tokens: generated)
-        }.value
-    }
-
-    /// Streaming generation. Yields each decoded token chunk via `AsyncThrowingStream`.
-    func generateStream(promptTokens: [Int]) -> AsyncThrowingStream<String, Error> {
-        AsyncThrowingStream { continuation in
-            Task.detached(priority: .userInitiated) {
-                do {
-                    guard !promptTokens.isEmpty else {
-                        throw CoreMLBackendError.generationFailed(reason: "prompt tokens are empty")
-                    }
-
-                    let state = self.engine.makeConversationState()
-
-                    var kvPos = 0
-                    var lastLogits: MLMultiArray = try self.engine.runStep(
-                        token: promptTokens[0], kvCachePosition: 0, state: state
-                    )
-                    kvPos = 1
-                    for token in promptTokens.dropFirst() {
-                        lastLogits = try self.engine.runStep(
-                            token: token, kvCachePosition: kvPos, state: state
-                        )
-                        kvPos += 1
-                    }
-
-                    var nextToken = self.sampler.sample(logits: lastLogits)
-
-                    for _ in 0 ..< self.maxNewTokens {
-                        if nextToken == self.engine.eosTokenId { break }
-                        let chunk = self.tokenizer.decode(token: nextToken)
-                        continuation.yield(chunk)
-                        lastLogits = try self.engine.runStep(
-                            token: nextToken, kvCachePosition: kvPos, state: state
-                        )
-                        kvPos += 1
-                        nextToken = self.sampler.sample(logits: lastLogits)
-                    }
-                    continuation.finish()
-                } catch {
-                    continuation.finish(throwing: error)
-                }
-            }
-        }
-    }
-}
+import Foundation
+import CoreML
+
+/// Orchestrates `CoreMLEngine` + `CoreMLTokenizer` + `CoreMLSampler` to
+/// produce text from a prompt via autoregressive decoding.
+///
+/// CoreML prediction note (iOS 18):
+///   `MLModel.prediction(from:using:options:)` is synchronous. We wrap the
+///   decode loop in a `Task.detached` (in `generateStream`) or simply call
+///   `runStep` directly in the async context for `generate`. Since `runStep`
+///   is not itself `async`, calling it in an `async` function does NOT suspend
+///   — it runs inline on the current executor. For long-running decodes the
+///   caller should call `generate` / `generateStream` from a background Task
+///   to avoid blocking the main actor.
+@available(iOS 18.0, macOS 15.0, *)
+internal struct CoreMLGenerator: @unchecked Sendable {
+    let engine: CoreMLEngine
+    let tokenizer: CoreMLTokenizer
+    let sampler: CoreMLSampler
+    let maxNewTokens: Int
+
+    /// Buffered generation. Runs the full decode loop and returns the decoded text.
+    func generate(promptTokens: [Int]) async throws -> String {
+        return try await Task.detached(priority: .userInitiated) {
+            guard !promptTokens.isEmpty else {
+                throw CoreMLBackendError.generationFailed(reason: "prompt tokens are empty")
+            }
+
+            var generated: [Int] = []
+            let state = self.engine.makeConversationState()
+
+            // Prefill + decode unified: each runStep returns logits for the
+            // *next* token at position (kvPos+1). After feeding all prompt
+            // tokens, the last logits give us our first generated token.
+            // (Previous iteration of this code re-fed promptTokens.last as a
+            // separate step, which double-counted that token in the KV
+            // cache.)
+            var kvPos = 0
+            var lastLogits: MLMultiArray = try self.engine.runStep(
+                token: promptTokens[0], kvCachePosition: 0, state: state
+            )
+            kvPos = 1
+            for token in promptTokens.dropFirst() {
+                lastLogits = try self.engine.runStep(
+                    token: token, kvCachePosition: kvPos, state: state
+                )
+                kvPos += 1
+            }
+
+            var nextToken = self.sampler.sample(logits: lastLogits)
+
+            for _ in 0 ..< self.maxNewTokens {
+                if nextToken == self.engine.eosTokenId { break }
+                generated.append(nextToken)
+                lastLogits = try self.engine.runStep(
+                    token: nextToken, kvCachePosition: kvPos, state: state
+                )
+                kvPos += 1
+                nextToken = self.sampler.sample(logits: lastLogits)
+            }
+
+            return self.tokenizer.decode(tokens: generated)
+        }.value
+    }
+
+    /// Streaming generation. Yields each decoded token chunk via `AsyncThrowingStream`.
+    func generateStream(promptTokens: [Int]) -> AsyncThrowingStream<String, Error> {
+        AsyncThrowingStream { continuation in
+            Task.detached(priority: .userInitiated) {
+                do {
+                    guard !promptTokens.isEmpty else {
+                        throw CoreMLBackendError.generationFailed(reason: "prompt tokens are empty")
+                    }
+
+                    let state = self.engine.makeConversationState()
+
+                    var kvPos = 0
+                    var lastLogits: MLMultiArray = try self.engine.runStep(
+                        token: promptTokens[0], kvCachePosition: 0, state: state
+                    )
+                    kvPos = 1
+                    for token in promptTokens.dropFirst() {
+                        lastLogits = try self.engine.runStep(
+                            token: token, kvCachePosition: kvPos, state: state
+                        )
+                        kvPos += 1
+                    }
+
+                    var nextToken = self.sampler.sample(logits: lastLogits)
+
+                    for _ in 0 ..< self.maxNewTokens {
+                        if nextToken == self.engine.eosTokenId { break }
+                        let chunk = self.tokenizer.decode(token: nextToken)
+                        continuation.yield(chunk)
+                        lastLogits = try self.engine.runStep(
+                            token: nextToken, kvCachePosition: kvPos, state: state
+                        )
+                        kvPos += 1
+                        nextToken = self.sampler.sample(logits: lastLogits)
+                    }
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: error)
+                }
+            }
+        }
+    }
+}

package/ios/Sources/DVAICoreMLCore/Internal/CoreMLSampler.swift

@@ -1,96 +1,96 @@
-import Foundation
-import CoreML
-
-/// Sampling strategies for autoregressive decoding.
-///
-/// Note on `seed:` — `SystemRandomNumberGenerator` cannot be seeded; for
-/// reproducible sampling a custom PRNG (e.g. Mulberry32) would be needed.
-/// Per the plan, we drop `seed:` from the public-facing init entirely rather
-/// than silently ignoring it. Apple-managed entropy is fine for production LLM
-/// sampling.
-internal struct CoreMLSampler {
-    let temperature: Float
-    let topP: Float
-    let topK: Int   // 0 = disabled
-
-    /// Sample a token id from a logits vector.
-    /// - Parameter logits: 1-D MLMultiArray<Float32> of length vocab_size.
-    func sample(logits: MLMultiArray) -> Int {
-        let count = logits.count
-        let ptr = UnsafeMutablePointer<Float32>(OpaquePointer(logits.dataPointer))
-
-        // 1. Greedy fast-path
-        if temperature <= 0 {
-            return argmax(ptr, count: count)
-        }
-
-        // 2. Apply temperature
-        var scaled = [Float](repeating: 0, count: count)
-        for i in 0 ..< count { scaled[i] = ptr[i] / temperature }
-
-        // 3. Optional top-K filter
-        if topK > 0 && topK < count {
-            applyTopK(&scaled, k: topK)
-        }
-
-        // 4. Softmax → probabilities
-        let probs = softmax(scaled)
-
-        // 5. Optional nucleus (top-p) filter
-        let final = topP < 1.0 ? applyTopP(probs, p: topP) : probs
-
-        // 6. Categorical draw
-        return categoricalSample(final)
-    }
-
-    // MARK: - Helpers
-
-    private func argmax(_ ptr: UnsafeMutablePointer<Float32>, count: Int) -> Int {
-        var bestIdx = 0
-        var bestVal = ptr[0]
-        for i in 1 ..< count {
-            if ptr[i] > bestVal { bestVal = ptr[i]; bestIdx = i }
-        }
-        return bestIdx
-    }
-
-    private func softmax(_ logits: [Float]) -> [Float] {
-        let maxVal = logits.max() ?? 0
-        var exps = logits.map { Float(exp(Double($0 - maxVal))) }
-        let sum = exps.reduce(0, +)
-        if sum > 0 { for i in 0 ..< exps.count { exps[i] /= sum } }
-        return exps
-    }
-
-    private func applyTopK(_ logits: inout [Float], k: Int) {
-        let kth = logits.sorted(by: >).prefix(k).last ?? -.greatestFiniteMagnitude
-        for i in 0 ..< logits.count where logits[i] < kth { logits[i] = -.greatestFiniteMagnitude }
-    }
-
-    private func applyTopP(_ probs: [Float], p: Float) -> [Float] {
-        let sorted = probs.enumerated().sorted { $0.element > $1.element }
-        var cum: Float = 0
-        var keep = Set<Int>()
-        for (idx, prob) in sorted {
-            keep.insert(idx)
-            cum += prob
-            if cum >= p { break }
-        }
-        var result = probs
-        for i in 0 ..< result.count where !keep.contains(i) { result[i] = 0 }
-        let sum = result.reduce(0, +)
-        if sum > 0 { for i in 0 ..< result.count { result[i] /= sum } }
-        return result
-    }
-
-    private func categoricalSample(_ probs: [Float]) -> Int {
-        var rng = SystemRandomNumberGenerator()
-        let r = Float.random(in: 0 ..< 1, using: &rng)
-        var cum: Float = 0
-        for i in 0 ..< probs.count {
-            cum += probs[i]
-            if r < cum { return i }
-        }
-        return probs.count - 1
-    }
-}
+import Foundation
+import CoreML
+
+/// Sampling strategies for autoregressive decoding.
+///
+/// Note on `seed:` — `SystemRandomNumberGenerator` cannot be seeded; for
+/// reproducible sampling a custom PRNG (e.g. Mulberry32) would be needed.
+/// Per the plan, we drop `seed:` from the public-facing init entirely rather
+/// than silently ignoring it. Apple-managed entropy is fine for production LLM
+/// sampling.
+internal struct CoreMLSampler {
+    let temperature: Float
+    let topP: Float
+    let topK: Int   // 0 = disabled
+
+    /// Sample a token id from a logits vector.
+    /// - Parameter logits: 1-D MLMultiArray<Float32> of length vocab_size.
+    func sample(logits: MLMultiArray) -> Int {
+        let count = logits.count
+        let ptr = UnsafeMutablePointer<Float32>(OpaquePointer(logits.dataPointer))
+
+        // 1. Greedy fast-path
+        if temperature <= 0 {
+            return argmax(ptr, count: count)
+        }
+
+        // 2. Apply temperature
+        var scaled = [Float](repeating: 0, count: count)
+        for i in 0 ..< count { scaled[i] = ptr[i] / temperature }
+
+        // 3. Optional top-K filter
+        if topK > 0 && topK < count {
+            applyTopK(&scaled, k: topK)
+        }
+
+        // 4. Softmax → probabilities
+        let probs = softmax(scaled)
+
+        // 5. Optional nucleus (top-p) filter
+        let final = topP < 1.0 ? applyTopP(probs, p: topP) : probs
+
+        // 6. Categorical draw
+        return categoricalSample(final)
+    }
+
+    // MARK: - Helpers
+
+    private func argmax(_ ptr: UnsafeMutablePointer<Float32>, count: Int) -> Int {
+        var bestIdx = 0
+        var bestVal = ptr[0]
+        for i in 1 ..< count {
+            if ptr[i] > bestVal { bestVal = ptr[i]; bestIdx = i }
+        }
+        return bestIdx
+    }
+
+    private func softmax(_ logits: [Float]) -> [Float] {
+        let maxVal = logits.max() ?? 0
+        var exps = logits.map { Float(exp(Double($0 - maxVal))) }
+        let sum = exps.reduce(0, +)
+        if sum > 0 { for i in 0 ..< exps.count { exps[i] /= sum } }
+        return exps
+    }
+
+    private func applyTopK(_ logits: inout [Float], k: Int) {
+        let kth = logits.sorted(by: >).prefix(k).last ?? -.greatestFiniteMagnitude
+        for i in 0 ..< logits.count where logits[i] < kth { logits[i] = -.greatestFiniteMagnitude }
+    }
+
+    private func applyTopP(_ probs: [Float], p: Float) -> [Float] {
+        let sorted = probs.enumerated().sorted { $0.element > $1.element }
+        var cum: Float = 0
+        var keep = Set<Int>()
+        for (idx, prob) in sorted {
+            keep.insert(idx)
+            cum += prob
+            if cum >= p { break }
+        }
+        var result = probs
+        for i in 0 ..< result.count where !keep.contains(i) { result[i] = 0 }
+        let sum = result.reduce(0, +)
+        if sum > 0 { for i in 0 ..< result.count { result[i] /= sum } }
+        return result
+    }
+
+    private func categoricalSample(_ probs: [Float]) -> Int {
+        var rng = SystemRandomNumberGenerator()
+        let r = Float.random(in: 0 ..< 1, using: &rng)
+        var cum: Float = 0
+        for i in 0 ..< probs.count {
+            cum += probs[i]
+            if r < cum { return i }
+        }
+        return probs.count - 1
+    }
+}

package/ios/Sources/DVAICoreMLCore/Internal/CoreMLTokenizer.swift

@@ -1,69 +1,69 @@
-import Foundation
-#if !COCOAPODS
-import Tokenizers
-#endif
-
-/// Loads a HuggingFace-style tokenizer.json + tokenizer_config.json from a
-/// local directory. Provides chat-template application, encode, and decode.
-///
-/// swift-transformers 1.3.0 API notes:
-///   - `AutoTokenizer.from(modelFolder:hubApi:strict:)` — hubApi and strict
-///     have default values so the two-arg form `from(modelFolder:)` is NOT
-///     available; must pass at minimum `modelFolder:`.
-///   - `Message` is `typealias Message = [String: any Sendable]` so we convert
-///     `[[String: String]]` → `[[String: any Sendable]]` before passing.
-///   - `applyChatTemplate(messages:)` has all other params defaulted.
-///   - `eosTokenId` is `Int?` (optional) — we fall back to 0 if absent.
-internal struct CoreMLTokenizer: @unchecked Sendable {
-    private let inner: any Tokenizer
-
-    init(tokenizerDir: URL) async throws {
-        do {
-            // `from(modelFolder:)` resolves to `from(modelFolder:hubApi:strict:)`
-            // with default HubApi() and strict: true.
-            self.inner = try await AutoTokenizer.from(modelFolder: tokenizerDir)
-        } catch {
-            throw CoreMLBackendError.tokenizerLoadFailed(reason: "\(error)")
-        }
-    }
-
-    /// Apply the model's chat template to convert messages into token IDs.
-    /// - Parameter messages: Array of {"role": ..., "content": ...} dicts.
-    /// - Parameter addGenerationPrompt: Append the generation-start marker.
-    func applyChatTemplate(
-        messages: [[String: String]],
-        addGenerationPrompt: Bool = true
-    ) throws -> [Int] {
-        // Convert [[String: String]] → [[String: any Sendable]] (Tokenizers.Message)
-        let normalized: [Message] = messages.map { dict in
-            var m: Message = [:]
-            for (k, v) in dict { m[k] = v }
-            return m
-        }
-        do {
-            // swift-transformers 1.x's applyChatTemplate signature drops the
-            // addGenerationPrompt parameter (defaulted to true server-side).
-            // The `addGenerationPrompt` knob in our wrapper is preserved for
-            // future API symmetry but currently passed through implicitly.
-            _ = addGenerationPrompt
-            return try inner.applyChatTemplate(messages: normalized)
-        } catch {
-            throw CoreMLBackendError.generationFailed(reason: "applyChatTemplate failed: \(error)")
-        }
-    }
-
-    func encode(text: String) -> [Int] {
-        inner.encode(text: text)
-    }
-
-    func decode(tokens: [Int]) -> String {
-        inner.decode(tokens: tokens, skipSpecialTokens: true)
-    }
-
-    func decode(token: Int) -> String {
-        decode(tokens: [token])
-    }
-
-    /// EOS token id. Falls back to 0 if the tokenizer config doesn't specify one.
-    var eosTokenId: Int { inner.eosTokenId ?? 0 }
-}
+import Foundation
+#if !COCOAPODS
+import Tokenizers
+#endif
+
+/// Loads a HuggingFace-style tokenizer.json + tokenizer_config.json from a
+/// local directory. Provides chat-template application, encode, and decode.
+///
+/// swift-transformers 1.3.0 API notes:
+///   - `AutoTokenizer.from(modelFolder:hubApi:strict:)` — hubApi and strict
+///     have default values so the two-arg form `from(modelFolder:)` is NOT
+///     available; must pass at minimum `modelFolder:`.
+///   - `Message` is `typealias Message = [String: any Sendable]` so we convert
+///     `[[String: String]]` → `[[String: any Sendable]]` before passing.
+///   - `applyChatTemplate(messages:)` has all other params defaulted.
+///   - `eosTokenId` is `Int?` (optional) — we fall back to 0 if absent.
+internal struct CoreMLTokenizer: @unchecked Sendable {
+    private let inner: any Tokenizer
+
+    init(tokenizerDir: URL) async throws {
+        do {
+            // `from(modelFolder:)` resolves to `from(modelFolder:hubApi:strict:)`
+            // with default HubApi() and strict: true.
+            self.inner = try await AutoTokenizer.from(modelFolder: tokenizerDir)
+        } catch {
+            throw CoreMLBackendError.tokenizerLoadFailed(reason: "\(error)")
+        }
+    }
+
+    /// Apply the model's chat template to convert messages into token IDs.
+    /// - Parameter messages: Array of {"role": ..., "content": ...} dicts.
+    /// - Parameter addGenerationPrompt: Append the generation-start marker.
+    func applyChatTemplate(
+        messages: [[String: String]],
+        addGenerationPrompt: Bool = true
+    ) throws -> [Int] {
+        // Convert [[String: String]] → [[String: any Sendable]] (Tokenizers.Message)
+        let normalized: [Message] = messages.map { dict in
+            var m: Message = [:]
+            for (k, v) in dict { m[k] = v }
+            return m
+        }
+        do {
+            // swift-transformers 1.x's applyChatTemplate signature drops the
+            // addGenerationPrompt parameter (defaulted to true server-side).
+            // The `addGenerationPrompt` knob in our wrapper is preserved for
+            // future API symmetry but currently passed through implicitly.
+            _ = addGenerationPrompt
+            return try inner.applyChatTemplate(messages: normalized)
+        } catch {
+            throw CoreMLBackendError.generationFailed(reason: "applyChatTemplate failed: \(error)")
+        }
+    }
+
+    func encode(text: String) -> [Int] {
+        inner.encode(text: text)
+    }
+
+    func decode(tokens: [Int]) -> String {
+        inner.decode(tokens: tokens, skipSpecialTokens: true)
+    }
+
+    func decode(token: Int) -> String {
+        decode(tokens: [token])
+    }
+
+    /// EOS token id. Falls back to 0 if the tokenizer config doesn't specify one.
+    var eosTokenId: Int { inner.eosTokenId ?? 0 }
+}

package/ios/Tests/DVAIBridgeTests/BackendSelectorTests.swift

@@ -1,53 +1,53 @@
-import XCTest
-@testable import DVAIBridge
-
-final class BackendSelectorTests: XCTestCase {
-    func testExplicitChoicePassesThrough() throws {
-        for kind in [BackendKind.llama, .foundation, .coreml] {
-            let resolved = try BackendSelector.resolve(kind, config: DVAIBridgeConfig())
-            XCTAssertEqual(resolved, kind)
-        }
-    }
-
-    func testAutoWithGGUFResolvesToLlama() throws {
-        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.gguf")
-        XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .llama)
-    }
-
-    func testAutoWithMlmodelcResolvesToCoreML() throws {
-        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.mlmodelc")
-        XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .coreml)
-    }
-
-    func testAutoWithMlpackageResolvesToCoreML() throws {
-        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.mlpackage")
-        XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .coreml)
-    }
-
-    func testAutoWithTaskFileThrows() {
-        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.task")
-        XCTAssertThrowsError(try BackendSelector.resolve(.auto, config: cfg)) { err in
-            guard case let DVAIBridgeError.configurationInvalid(reason) = err else {
-                return XCTFail("wrong error type")
-            }
-            XCTAssertTrue(reason.contains("Android"))
-        }
-    }
-
-    func testAutoWithUnknownExtensionThrows() {
-        let cfg = DVAIBridgeConfig(modelPath: "/path/to/something.unknown")
-        XCTAssertThrowsError(try BackendSelector.resolve(.auto, config: cfg))
-    }
-
-    func testAutoWithNoModelPathOnIOS26ResolvesToFoundation() throws {
-        // This test only meaningfully runs on iOS 26+. On older simulators
-        // the no-modelPath branch throws. Both outcomes are well-defined;
-        // assert the right one based on availability.
-        let cfg = DVAIBridgeConfig(modelPath: nil)
-        if #available(iOS 26.0, macOS 26.0, *) {
-            XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .foundation)
-        } else {
-            XCTAssertThrowsError(try BackendSelector.resolve(.auto, config: cfg))
-        }
-    }
-}
+import XCTest
+@testable import DVAIBridge
+
+final class BackendSelectorTests: XCTestCase {
+    func testExplicitChoicePassesThrough() throws {
+        for kind in [BackendKind.llama, .foundation, .coreml] {
+            let resolved = try BackendSelector.resolve(kind, config: DVAIBridgeConfig())
+            XCTAssertEqual(resolved, kind)
+        }
+    }
+
+    func testAutoWithGGUFResolvesToLlama() throws {
+        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.gguf")
+        XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .llama)
+    }
+
+    func testAutoWithMlmodelcResolvesToCoreML() throws {
+        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.mlmodelc")
+        XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .coreml)
+    }
+
+    func testAutoWithMlpackageResolvesToCoreML() throws {
+        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.mlpackage")
+        XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .coreml)
+    }
+
+    func testAutoWithTaskFileThrows() {
+        let cfg = DVAIBridgeConfig(modelPath: "/path/to/model.task")
+        XCTAssertThrowsError(try BackendSelector.resolve(.auto, config: cfg)) { err in
+            guard case let DVAIBridgeError.configurationInvalid(reason) = err else {
+                return XCTFail("wrong error type")
+            }
+            XCTAssertTrue(reason.contains("Android"))
+        }
+    }
+
+    func testAutoWithUnknownExtensionThrows() {
+        let cfg = DVAIBridgeConfig(modelPath: "/path/to/something.unknown")
+        XCTAssertThrowsError(try BackendSelector.resolve(.auto, config: cfg))
+    }
+
+    func testAutoWithNoModelPathOnIOS26ResolvesToFoundation() throws {
+        // This test only meaningfully runs on iOS 26+. On older simulators
+        // the no-modelPath branch throws. Both outcomes are well-defined;
+        // assert the right one based on availability.
+        let cfg = DVAIBridgeConfig(modelPath: nil)
+        if #available(iOS 26.0, macOS 26.0, *) {
+            XCTAssertEqual(try BackendSelector.resolve(.auto, config: cfg), .foundation)
+        } else {
+            XCTAssertThrowsError(try BackendSelector.resolve(.auto, config: cfg))
+        }
+    }
+}