import Foundation public enum ProviderRuntime: Sendable {    case app    case cli} public enum ProviderSourceMode: String, CaseIterable, Sendable {    case auto    case web    case cli    case oauth     public var usesWeb: Bool {        self == .auto || self == .web    }} public struct ProviderFetchContext: Sendable {    public let runtime: ProviderRuntime    public let sourceMode: ProviderSourceMode    public let includeCredits: Bool    public let webTimeout: TimeInterval    public let webDebugDumpHTML: Bool    public let verbose: Bool    public let env: [String: String]    public let settings: ProviderSettingsSnapshot?    public let fetcher: UsageFetcher    public let claudeFetcher: any ClaudeUsageFetching    public let browserDetection: BrowserDetection     public init(        runtime: ProviderRuntime,        sourceMode: ProviderSourceMode,        includeCredits: Bool,        webTimeout: TimeInterval,        webDebugDumpHTML: Bool,        verbose: Bool,        env: [String: String],        settings: ProviderSettingsSnapshot?,        fetcher: UsageFetcher,        claudeFetcher: any ClaudeUsageFetching,        browserDetection: BrowserDetection)    {        self.runtime = runtime        self.sourceMode = sourceMode        self.includeCredits = includeCredits        self.webTimeout = webTimeout        self.webDebugDumpHTML = webDebugDumpHTML        self.verbose = verbose        self.env = env        self.settings = settings        self.fetcher = fetcher        self.claudeFetcher = claudeFetcher        self.browserDetection = browserDetection    }} public struct ProviderFetchResult: Sendable {    public let usage: UsageSnapshot    public let credits: CreditsSnapshot?    public let dashboard: OpenAIDashboardSnapshot?    public let sourceLabel: String    public let strategyID: String    public let strategyKind: ProviderFetchKind     public init(        usage: UsageSnapshot,        credits: CreditsSnapshot?,        dashboard: OpenAIDashboardSnapshot?,        sourceLabel: String,        strategyID: String,        strategyKind: ProviderFetchKind)    {        self.usage = usage        self.credits = credits        self.dashboard = dashboard        self.sourceLabel = sourceLabel        self.strategyID = strategyID        self.strategyKind = strategyKind    }} public struct ProviderFetchAttempt: Sendable {    public let strategyID: String    public let kind: ProviderFetchKind    public let wasAvailable: Bool    public let errorDescription: String?     public init(strategyID: String, kind: ProviderFetchKind, wasAvailable: Bool, errorDescription: String?) {        self.strategyID = strategyID        self.kind = kind        self.wasAvailable = wasAvailable        self.errorDescription = errorDescription    }} public struct ProviderFetchOutcome: @unchecked Sendable {    public let result: Result<ProviderFetchResult, Error>    public let attempts: [ProviderFetchAttempt]     public init(result: Result<ProviderFetchResult, Error>, attempts: [ProviderFetchAttempt]) {        self.result = result        self.attempts = attempts    }} public enum ProviderFetchError: LocalizedError, Sendable {    case noAvailableStrategy(UsageProvider)     public var errorDescription: String? {        switch self {        case let .noAvailableStrategy(provider):            "No available fetch strategy for \(provider.rawValue)."        }    }} public enum ProviderFetchKind: Sendable {    case cli    case web    case oauth    case apiToken    case localProbe    case webDashboard} public protocol ProviderFetchStrategy: Sendable {    var id: String { get }    var kind: ProviderFetchKind { get }    func isAvailable(_ context: ProviderFetchContext) async -> Bool    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool} extension ProviderFetchStrategy {    public func makeResult(        usage: UsageSnapshot,        credits: CreditsSnapshot? = nil,        dashboard: OpenAIDashboardSnapshot? = nil,        sourceLabel: String) -> ProviderFetchResult    {        ProviderFetchResult(            usage: usage,            credits: credits,            dashboard: dashboard,            sourceLabel: sourceLabel,            strategyID: self.id,            strategyKind: self.kind)    }} public struct ProviderFetchPipeline: Sendable {    public let resolveStrategies: @Sendable (ProviderFetchContext) async -> [any ProviderFetchStrategy]     public init(resolveStrategies: @escaping @Sendable (ProviderFetchContext) async -> [any ProviderFetchStrategy]) {        self.resolveStrategies = resolveStrategies    }     public func fetch(context: ProviderFetchContext, provider: UsageProvider) async -> ProviderFetchOutcome {        let strategies = await self.resolveStrategies(context)        var attempts: [ProviderFetchAttempt] = []        attempts.reserveCapacity(strategies.count)         for strategy in strategies {            let available = await strategy.isAvailable(context)             guard available else {                attempts.append(ProviderFetchAttempt(                    strategyID: strategy.id,                    kind: strategy.kind,                    wasAvailable: false,                    errorDescription: nil))                continue            }             do {                let result = try await strategy.fetch(context)                attempts.append(ProviderFetchAttempt(                    strategyID: strategy.id,                    kind: strategy.kind,                    wasAvailable: true,                    errorDescription: nil))                return ProviderFetchOutcome(result: .success(result), attempts: attempts)            } catch {                attempts.append(ProviderFetchAttempt(                    strategyID: strategy.id,                    kind: strategy.kind,                    wasAvailable: true,                    errorDescription: error.localizedDescription))                if strategy.shouldFallback(on: error, context: context) {                    continue                }                return ProviderFetchOutcome(result: .failure(error), attempts: attempts)            }        }         let error = ProviderFetchError.noAvailableStrategy(provider)        return ProviderFetchOutcome(result: .failure(error), attempts: attempts)    }} public struct ProviderFetchPlan: Sendable {    public let sourceModes: Set<ProviderSourceMode>    public let pipeline: ProviderFetchPipeline     public init(sourceModes: Set<ProviderSourceMode>, pipeline: ProviderFetchPipeline) {        self.sourceModes = sourceModes        self.pipeline = pipeline    }     public func fetchOutcome(context: ProviderFetchContext, provider: UsageProvider) async -> ProviderFetchOutcome {        await self.pipeline.fetch(context: context, provider: provider)    }}