@sriinnu/runic 1.2.0 → 2.11.1

package/Tests/RunicTests/PathBuilderTests.swift

@@ -1,237 +0,0 @@
-import RunicCore
-import Foundation
-import Testing
-@testable import Runic
-
-@Suite
-struct PathBuilderTests {
-    @Test
-    func mergesLoginShellPathWhenAvailable() {
-        let seeded = PathBuilder.effectivePATH(
-            purposes: [.rpc],
-            env: ["PATH": "/custom/bin:/usr/bin"],
-            loginPATH: ["/login/bin", "/login/alt"])
-        #expect(seeded == "/login/bin:/login/alt:/custom/bin:/usr/bin")
-    }
-
-    @Test
-    func fallsBackToExistingPathWhenNoLoginPath() {
-        let seeded = PathBuilder.effectivePATH(
-            purposes: [.tty],
-            env: ["PATH": "/custom/bin:/usr/bin"],
-            loginPATH: nil)
-        #expect(seeded == "/custom/bin:/usr/bin")
-    }
-
-    @Test
-    func usesFallbackWhenNoPathAvailable() {
-        let seeded = PathBuilder.effectivePATH(
-            purposes: [.tty],
-            env: [:],
-            loginPATH: nil)
-        #expect(seeded == "/usr/bin:/bin:/usr/sbin:/sbin")
-    }
-
-    @Test
-    func resolvesCodexFromEnvOverride() {
-        let overridePath = "/custom/bin/codex"
-        let fm = MockFileManager(executables: [overridePath])
-
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["CODEX_CLI_PATH": overridePath],
-            loginPATH: nil,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == overridePath)
-    }
-
-    @Test
-    func resolvesCodexFromLoginPath() {
-        let fm = MockFileManager(executables: ["/login/bin/codex"])
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["PATH": "/env/bin"],
-            loginPATH: ["/login/bin"],
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/login/bin/codex")
-    }
-
-    @Test
-    func resolvesCodexFromEnvPath() {
-        let fm = MockFileManager(executables: ["/env/bin/codex"])
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["PATH": "/env/bin:/usr/bin"],
-            loginPATH: nil,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/env/bin/codex")
-    }
-
-    @Test
-    func resolvesCodexFromInteractiveShell() {
-        let fm = MockFileManager(executables: ["/shell/bin/codex"])
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
-            #expect(tool == "codex")
-            #expect(shell == "/bin/zsh")
-            #expect(timeout == 2.0)
-            _ = fileManager
-            return "/shell/bin/codex"
-        }
-
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/shell/bin/codex")
-    }
-
-    @Test
-    func resolvesClaudeFromInteractiveShell() {
-        let fm = MockFileManager(executables: ["/shell/bin/claude"])
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
-            #expect(tool == "claude")
-            #expect(shell == "/bin/zsh")
-            #expect(timeout == 2.0)
-            _ = fileManager
-            return "/shell/bin/claude"
-        }
-
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/shell/bin/claude")
-    }
-
-    @Test
-    func resolvesGeminiFromInteractiveShell() {
-        let fm = MockFileManager(executables: ["/shell/bin/gemini"])
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
-            #expect(tool == "gemini")
-            #expect(shell == "/bin/zsh")
-            #expect(timeout == 2.0)
-            _ = fileManager
-            return "/shell/bin/gemini"
-        }
-
-        let resolved = BinaryLocator.resolveGeminiBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/shell/bin/gemini")
-    }
-
-    @Test
-    func resolvesClaudeFromLoginPath() {
-        let fm = MockFileManager(executables: ["/login/bin/claude"])
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["PATH": "/env/bin"],
-            loginPATH: ["/login/bin"],
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/login/bin/claude")
-    }
-
-    @Test
-    func resolvesClaudeFromAliasWhenOtherLookupsFail() {
-        let aliasPath = "/home/test/.claude/local/bin/claude"
-        let fm = MockFileManager(executables: [aliasPath])
-        var aliasCalled = false
-        let aliasResolver: (String, String?, TimeInterval, FileManager, String)
-            -> String? = { tool, shell, timeout, _, home in
-                aliasCalled = true
-                #expect(tool == "claude")
-                #expect(shell == "/bin/zsh")
-                #expect(timeout == 2.0)
-                #expect(home == "/home/test")
-                return aliasPath
-            }
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
-            nil
-        }
-
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            aliasResolver: aliasResolver,
-            fileManager: fm,
-            home: "/home/test")
-
-        #expect(aliasCalled)
-        #expect(resolved == aliasPath)
-    }
-
-    @Test
-    func resolvesCodexFromAliasWhenOtherLookupsFail() {
-        let aliasPath = "/home/test/.codex/bin/codex"
-        let fm = MockFileManager(executables: [aliasPath])
-        var aliasCalled = false
-        let aliasResolver: (String, String?, TimeInterval, FileManager, String)
-            -> String? = { tool, shell, timeout, _, home in
-                aliasCalled = true
-                #expect(tool == "codex")
-                #expect(shell == "/bin/zsh")
-                #expect(timeout == 2.0)
-                #expect(home == "/home/test")
-                return aliasPath
-            }
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
-            nil
-        }
-
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            aliasResolver: aliasResolver,
-            fileManager: fm,
-            home: "/home/test")
-
-        #expect(aliasCalled)
-        #expect(resolved == aliasPath)
-    }
-
-    @Test
-    func skipsAliasWhenCommandVResolves() {
-        let path = "/shell/bin/claude"
-        let fm = MockFileManager(executables: [path])
-        var aliasCalled = false
-        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in
-            aliasCalled = true
-            return "/alias/claude"
-        }
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
-            path
-        }
-
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            aliasResolver: aliasResolver,
-            fileManager: fm,
-            home: "/home/test")
-
-        #expect(!aliasCalled)
-        #expect(resolved == path)
-    }
-}
-
-private final class MockFileManager: FileManager {
-    private let executables: Set<String>
-
-    init(executables: Set<String>) {
-        self.executables = executables
-    }
-
-    override func isExecutableFile(atPath path: String) -> Bool {
-        self.executables.contains(path)
-    }
-}

package/Tests/RunicTests/ProviderFetchPipelineTests.swift

@@ -1,160 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-@Suite
-struct ProviderFetchPipelineTests {
-    private struct SlowStrategy: ProviderFetchStrategy {
-        let id: String
-        let kind: ProviderFetchKind = .api
-        let shouldFallbackValue: Bool
-
-        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-            true
-        }
-
-        func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-            while true {
-                try await Task.sleep(for: .milliseconds(10))
-            }
-        }
-
-        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-            self.shouldFallbackValue
-        }
-    }
-
-    private struct FailingStrategy: ProviderFetchStrategy {
-        let id: String = "provider.fetchPipeline.fail"
-        let kind: ProviderFetchKind = .api
-        let error: Error
-        let fallback: Bool
-
-        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-            true
-        }
-
-        func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
-            throw self.error
-        }
-
-        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-            self.fallback
-        }
-    }
-
-    private struct FastSuccessStrategy: ProviderFetchStrategy {
-        let id: String = "provider.fetchPipeline.success"
-        let kind: ProviderFetchKind = .api
-        let result: ProviderFetchResult
-
-        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-            true
-        }
-
-        func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
-            self.result
-        }
-
-        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-            false
-        }
-    }
-
-    private final class DummyClaudeFetcher: ClaudeUsageFetching, @unchecked Sendable {
-        func loadLatestUsage(model: String) async throws -> ClaudeUsageSnapshot {
-            throw URLError(.unsupportedURL)
-        }
-
-        func debugRawProbe(model: String) async -> String {
-            ""
-        }
-
-        func detectVersion() -> String? {
-            nil
-        }
-    }
-
-    private func makeContext() -> ProviderFetchContext {
-        ProviderFetchContext(
-            runtime: .app,
-            sourceMode: .auto,
-            includeCredits: false,
-            webTimeout: 60,
-            webDebugDumpHTML: false,
-            verbose: false,
-            env: [:],
-            settings: nil,
-            fetcher: UsageFetcher(environment: [:]),
-            claudeFetcher: DummyClaudeFetcher())
-    }
-
-    @Test
-    func hangsAreConvertedToStrategyTimeout() async {
-        let pipeline = ProviderFetchPipeline(
-            resolveStrategies: { _ in [SlowStrategy(id: "provider.fetchPipeline.hang", shouldFallbackValue: false)] },
-            strategyTimeout: 0.05)
-        let outcome = await pipeline.fetch(context: self.makeContext(), provider: .kimi)
-
-        #expect(!outcome.attempts.isEmpty)
-        #expect(outcome.attempts.count == 1)
-        #expect(outcome.attempts[0].strategyID == "provider.fetchPipeline.hang")
-        #expect(outcome.attempts[0].wasAvailable == true)
-
-        guard case .failure(let error) = outcome.result else {
-            Issue.record("Expected fetch failure")
-            return
-        }
-        guard case let .strategyTimeout(provider, strategyID, timeoutSeconds) = error as? ProviderFetchError else {
-            Issue.record("Expected strategy timeout error")
-            return
-        }
-        #expect(provider == .kimi)
-        #expect(strategyID == "provider.fetchPipeline.hang")
-        #expect(timeoutSeconds == 0.05)
-    }
-
-    @Test
-    func strategyFallbackStillHonorsOrder() async {
-        let expected = Self.makeStubResult()
-        let pipeline = ProviderFetchPipeline(
-            resolveStrategies: { _ in [
-                FailingStrategy(error: URLError(.timedOut), fallback: true),
-                FastSuccessStrategy(result: expected),
-            ] },
-            strategyTimeout: 1)
-
-        let outcome = await pipeline.fetch(context: self.makeContext(), provider: .kimi)
-        let result = try? outcome.result.get()
-
-        #expect(result?.strategyID == expected.strategyID)
-        #expect(result?.strategyKind == expected.strategyKind)
-        #expect(result?.sourceLabel == expected.sourceLabel)
-        #expect(result?.usage.primary.resetDescription == expected.usage.primary.resetDescription)
-        #expect(outcome.attempts.count == 2)
-        #expect(outcome.attempts[0].wasAvailable)
-        #expect(outcome.attempts[0].errorDescription != nil)
-        #expect(outcome.attempts[1].wasAvailable)
-        #expect(outcome.attempts[1].errorDescription == nil)
-    }
-
-    private static func makeStubResult() -> ProviderFetchResult {
-        let usage = UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 1,
-                windowMinutes: nil,
-                resetsAt: nil,
-                resetDescription: "test"),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: nil)
-        return ProviderFetchResult(
-            usage: usage,
-            credits: nil,
-            dashboard: nil,
-            sourceLabel: "test",
-            strategyID: "provider.fetchPipeline.success",
-            strategyKind: .api)
-    }
-}

package/Tests/RunicTests/ProviderIconResourcesTests.swift

@@ -1,38 +0,0 @@
-import AppKit
-import Foundation
-import Testing
-
-@MainActor
-@Suite
-struct ProviderIconResourcesTests {
-    @Test
-    func providerIconSVGsExist() throws {
-        let root = try Self.repoRoot()
-        let resources = root.appending(path: "Sources/Runic/Resources", directoryHint: .isDirectory)
-
-        let slugs = ["codex", "claude", "zai", "cursor", "gemini", "antigravity", "factory", "copilot"]
-        for slug in slugs {
-            let url = resources.appending(path: "ProviderIcon-\(slug).svg")
-            #expect(
-                FileManager.default.fileExists(atPath: url.path(percentEncoded: false)),
-                "Missing SVG for \(slug)")
-
-            let image = NSImage(contentsOf: url)
-            #expect(image != nil, "Could not load SVG as NSImage for \(slug)")
-        }
-    }
-
-    private static func repoRoot() throws -> URL {
-        var dir = URL(filePath: #filePath).deletingLastPathComponent()
-        for _ in 0..<12 {
-            let candidate = dir.appending(path: "Package.swift")
-            if FileManager.default.fileExists(atPath: candidate.path(percentEncoded: false)) {
-                return dir
-            }
-            dir.deleteLastPathComponent()
-        }
-        throw NSError(domain: "ProviderIconResourcesTests", code: 2, userInfo: [
-            NSLocalizedDescriptionKey: "Could not locate repo root (Package.swift) from \(#filePath)",
-        ])
-    }
-}

package/Tests/RunicTests/ProviderMetadataStatusLinkTests.swift

@@ -1,16 +0,0 @@
-import Testing
-@testable import RunicCore
-
-@Suite
-struct ProviderMetadataStatusLinkTests {
-    @Test
-    func workspaceStatusLinkMatchesProductID() {
-        for (provider, meta) in ProviderDefaults.metadata {
-            guard let productID = meta.statusWorkspaceProductID else { continue }
-            let expected = "https://www.google.com/appsstatus/dashboard/products/\(productID)/history"
-            #expect(
-                meta.statusLinkURL == expected,
-                "Expected \(provider.rawValue) statusLinkURL to be \(expected)")
-        }
-    }
-}

package/Tests/RunicTests/ProviderRegistryTests.swift

@@ -1,29 +0,0 @@
-import RunicCore
-import XCTest
-
-final class ProviderRegistryTests: XCTestCase {
-    func test_descriptorRegistryIsCompleteAndDeterministic() {
-        let descriptors = ProviderDescriptorRegistry.all
-        let ids = descriptors.map(\.id)
-
-        XCTAssertFalse(descriptors.isEmpty, "ProviderDescriptorRegistry must not be empty.")
-        XCTAssertEqual(Set(ids).count, ids.count, "ProviderDescriptorRegistry contains duplicate IDs.")
-
-        let missing = Set(UsageProvider.allCases).subtracting(ids)
-        XCTAssertTrue(missing.isEmpty, "Missing descriptors for providers: \(missing).")
-
-        let secondPass = ProviderDescriptorRegistry.all.map(\.id)
-        XCTAssertEqual(ids, secondPass, "ProviderDescriptorRegistry order changed between reads.")
-    }
-
-    func test_providerUsageCoverageFlagsForQuotaModelProviders() {
-        let metadata = ProviderDefaults.metadata
-
-        XCTAssertTrue(
-            metadata[.gemini]?.usageCoverage.supportsModelBreakdown == true,
-            "Gemini should advertise model breakdown coverage from quota windows.")
-        XCTAssertTrue(
-            metadata[.antigravity]?.usageCoverage.supportsModelBreakdown == true,
-            "Antigravity should advertise model breakdown coverage from quota windows.")
-    }
-}

package/Tests/RunicTests/ProviderSettingsDescriptorTests.swift

@@ -1,202 +0,0 @@
-import RunicCore
-import Foundation
-import SwiftUI
-import Testing
-@testable import Runic
-
-@MainActor
-@Suite
-struct ProviderSettingsDescriptorTests {
-    @Test
-    func toggleIDsAreUniqueAcrossProviders() {
-        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-unique")!
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-unique")
-        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        var statusByID: [String: String] = [:]
-        var lastRunAtByID: [String: Date] = [:]
-        var seenToggleIDs: Set<String> = []
-        var seenActionIDs: Set<String> = []
-
-        for provider in UsageProvider.allCases {
-            let context = ProviderSettingsContext(
-                provider: provider,
-                settings: settings,
-                store: store,
-                boolBinding: { keyPath in
-                    Binding(
-                        get: { settings[keyPath: keyPath] },
-                        set: { settings[keyPath: keyPath] = $0 })
-                },
-                stringBinding: { keyPath in
-                    Binding(
-                        get: { settings[keyPath: keyPath] },
-                        set: { settings[keyPath: keyPath] = $0 })
-                },
-                statusText: { id in statusByID[id] },
-                setStatusText: { id, text in
-                    if let text {
-                        statusByID[id] = text
-                    } else {
-                        statusByID.removeValue(forKey: id)
-                    }
-                },
-                lastAppActiveRunAt: { id in lastRunAtByID[id] },
-                setLastAppActiveRunAt: { id, date in
-                    if let date {
-                        lastRunAtByID[id] = date
-                    } else {
-                        lastRunAtByID.removeValue(forKey: id)
-                    }
-                },
-                requestConfirmation: { _ in })
-
-            let impl = ProviderCatalog.implementation(for: provider)!
-            let toggles = impl.settingsToggles(context: context)
-            for toggle in toggles {
-                #expect(!seenToggleIDs.contains(toggle.id))
-                seenToggleIDs.insert(toggle.id)
-
-                for action in toggle.actions {
-                    #expect(!seenActionIDs.contains(action.id))
-                    seenActionIDs.insert(action.id)
-                }
-            }
-        }
-    }
-
-    @Test
-    func codexDoesNotExposeOpenAIWebToggle() {
-        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-codex")!
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-codex")
-        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        let context = ProviderSettingsContext(
-            provider: .codex,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
-
-        let toggles = CodexProviderImplementation().settingsToggles(context: context)
-        #expect(toggles.isEmpty)
-    }
-
-    @Test
-    func claudeDoesNotExposeSettingsToggles() {
-        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-claude")!
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-claude")
-        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        let context = ProviderSettingsContext(
-            provider: .claude,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
-        let toggles = ClaudeProviderImplementation().settingsToggles(context: context)
-        #expect(toggles.isEmpty)
-    }
-
-    @Test
-    func claudeWebExtrasAutoDisablesWhenLeavingCLI() {
-        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-claude-invariant")!
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-claude-invariant")
-        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
-        settings.debugMenuEnabled = true
-        settings.claudeUsageDataSource = .cli
-        settings.claudeWebExtrasEnabled = true
-
-        settings.claudeUsageDataSource = .oauth
-        #expect(settings.claudeWebExtrasEnabled == false)
-    }
-
-    @Test
-    func extraProvidersExposeExpectedSettingsFields() {
-        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-extra-fields")!
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-extra-fields")
-        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        let expectedFields: [UsageProvider: Set<String>] = [
-            .kimi: ["kimi-api-token"],
-            .auggie: ["auggie-api-token"],
-            .openrouter: ["openrouter-api-token"],
-            .bedrock: ["bedrock-region", "bedrock-aws-profile", "bedrock-model-id"],
-        ]
-
-        for (provider, expected) in expectedFields {
-            guard let impl = ProviderCatalog.implementation(for: provider) else {
-                #expect(Bool(false), "Missing provider implementation for \(provider.rawValue).")
-                continue
-            }
-            let context = self.makeSettingsContext(provider: provider, settings: settings, store: store)
-            let visibleFields = impl.settingsFields(context: context).filter { $0.isVisible?() ?? true }
-            let fieldIDs = Set(visibleFields.map(\.id))
-            #expect(fieldIDs.isSuperset(of: expected))
-            #expect(!visibleFields.isEmpty)
-        }
-    }
-
-    @Test
-    func allProvidersHaveAppSideImplementation() {
-        for provider in UsageProvider.allCases {
-            #expect(ProviderCatalog.implementation(for: provider) != nil)
-        }
-    }
-
-    private func makeSettingsContext(
-        provider: UsageProvider,
-        settings: SettingsStore,
-        store: UsageStore) -> ProviderSettingsContext
-    {
-        ProviderSettingsContext(
-            provider: provider,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
-    }
-}