@sriinnu/runic 1.2.0 → 2.11.1

package/Sources/RunicCore/UsageLedger/UsageLedgerProjectIdentity.swift

@@ -1,245 +0,0 @@
-import Foundation
-
-public enum UsageLedgerProjectNameConfidence: String, Sendable, Codable {
-    case none
-    case low
-    case medium
-    case high
-
-    var rank: Int {
-        switch self {
-        case .none: 0
-        case .low: 1
-        case .medium: 2
-        case .high: 3
-        }
-    }
-}
-
-public enum UsageLedgerProjectNameSource: String, Sendable, Codable {
-    case unknown
-    case projectName
-    case projectID
-    case inferredFromPath
-    case inferredFromName
-    case budgetOverride
-}
-
-public struct UsageLedgerProjectIdentity: Sendable, Codable, Hashable {
-    public let key: String?
-    public let projectID: String?
-    public let displayName: String?
-    public let confidence: UsageLedgerProjectNameConfidence
-    public let source: UsageLedgerProjectNameSource
-    public let workspaceHash: String?
-    public let provenance: String?
-
-    public init(
-        key: String?,
-        projectID: String?,
-        displayName: String?,
-        confidence: UsageLedgerProjectNameConfidence,
-        source: UsageLedgerProjectNameSource,
-        workspaceHash: String?,
-        provenance: String?)
-    {
-        self.key = key
-        self.projectID = projectID
-        self.displayName = displayName
-        self.confidence = confidence
-        self.source = source
-        self.workspaceHash = workspaceHash
-        self.provenance = provenance
-    }
-}
-
-public enum UsageLedgerProjectIdentityResolver {
-    public static func resolve(
-        provider _: UsageProvider,
-        projectID: String?,
-        projectName: String?,
-        budgetNameOverride: String? = nil) -> UsageLedgerProjectIdentity
-    {
-        let normalizedProjectID = normalizedIdentifier(projectID)
-        let normalizedProjectName = normalizedDisplay(projectName)
-        let budgetName = normalizedDisplay(budgetNameOverride)
-        let workspaceCandidate = firstPathLikeValue(candidates: [projectID, projectName])
-        let workspaceHash = workspaceCandidate.map(stablePathHash)
-        let workspaceSuffix = workspaceHash.map { "#w:\($0.prefix(8))" } ?? ""
-
-        var displayName: String?
-        var confidence: UsageLedgerProjectNameConfidence = .none
-        var source: UsageLedgerProjectNameSource = .unknown
-        var provenance: String?
-
-        if let budgetName {
-            displayName = budgetName
-            confidence = .high
-            source = .budgetOverride
-            provenance = "budget_override"
-        } else if let normalizedProjectName {
-            displayName = normalizedProjectName
-            confidence = .high
-            source = .projectName
-            provenance = "entry.projectName"
-        } else if let pathTail = inferredPathTail(from: projectID) {
-            displayName = pathTail
-            confidence = .medium
-            source = .inferredFromPath
-            provenance = "path_tail(projectID)"
-        } else if let readableID = readableIdentifier(normalizedProjectID) {
-            displayName = readableID
-            confidence = .low
-            source = .projectID
-            provenance = "entry.projectID"
-        } else if let inferredFromName = inferredNameToken(from: projectName) {
-            displayName = inferredFromName
-            confidence = .low
-            source = .inferredFromName
-            provenance = "inferred(projectName)"
-        }
-
-        let key: String?
-        if let normalizedProjectID {
-            key = "id:\(normalizedProjectID.lowercased())\(workspaceSuffix)"
-        } else if let seed = displayName {
-            let slug = slugify(seed)
-            key = slug.isEmpty ? nil : "name:\(slug)\(workspaceSuffix)"
-        } else {
-            key = nil
-        }
-
-        return UsageLedgerProjectIdentity(
-            key: key,
-            projectID: normalizedProjectID,
-            displayName: displayName,
-            confidence: confidence,
-            source: source,
-            workspaceHash: workspaceHash,
-            provenance: provenance)
-    }
-
-    public static func fallbackDisplayName(projectID: String?) -> String? {
-        if let tail = inferredPathTail(from: projectID) {
-            return tail
-        }
-        guard let normalized = normalizedIdentifier(projectID), !normalized.isEmpty else {
-            return nil
-        }
-        if normalized.contains("/") || normalized.contains("\\") {
-            return nil
-        }
-        return readableIdentifier(normalized)
-    }
-
-    private static func normalizedIdentifier(_ value: String?) -> String? {
-        let cleaned = normalizedDisplay(value)
-        guard let cleaned, !cleaned.isEmpty else { return nil }
-        return cleaned
-    }
-
-    private static func normalizedDisplay(_ value: String?) -> String? {
-        guard let value else { return nil }
-        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !trimmed.isEmpty else { return nil }
-        let pieces = trimmed.split(whereSeparator: { $0.isWhitespace })
-        guard !pieces.isEmpty else { return nil }
-        return pieces.joined(separator: " ")
-    }
-
-    private static func inferredPathTail(from value: String?) -> String? {
-        guard let value else { return nil }
-        let separators = CharacterSet(charactersIn: "/\\")
-        guard value.rangeOfCharacter(from: separators) != nil else { return nil }
-
-        let parts = value.split { ch in
-            ch == "/" || ch == "\\"
-        }
-        guard let last = parts.last else { return nil }
-        let tail = normalizedDisplay(String(last))
-        guard let tail else { return nil }
-        guard !looksOpaqueIdentifier(tail) else { return nil }
-        return tail
-    }
-
-    private static func readableIdentifier(_ value: String?) -> String? {
-        guard let value else { return nil }
-        guard !value.isEmpty else { return nil }
-        guard !looksOpaqueIdentifier(value) else { return nil }
-        return value
-    }
-
-    private static func inferredNameToken(from value: String?) -> String? {
-        let normalized = normalizedDisplay(value)
-        guard let normalized, !normalized.isEmpty else { return nil }
-        let slug = slugify(normalized)
-        guard !slug.isEmpty else { return nil }
-        let titleCased = slug.split(separator: "-")
-            .map { token -> String in
-                guard let first = token.first else { return "" }
-                return "\(String(first).uppercased())\(token.dropFirst())"
-            }
-            .joined(separator: " ")
-        return titleCased.isEmpty ? nil : titleCased
-    }
-
-    private static func looksOpaqueIdentifier(_ value: String) -> Bool {
-        if value.count >= 24 {
-            let opaqueCharset = CharacterSet(charactersIn: "0123456789abcdefABCDEF-")
-            if value.unicodeScalars.allSatisfy({ opaqueCharset.contains($0) }) {
-                return true
-            }
-        }
-        if value.count > 64 {
-            return true
-        }
-        return false
-    }
-
-    private static func slugify(_ value: String) -> String {
-        let folded = value.folding(options: [.diacriticInsensitive, .caseInsensitive, .widthInsensitive], locale: .init(identifier: "en_US_POSIX"))
-        var scalarBuffer: [UnicodeScalar] = []
-        scalarBuffer.reserveCapacity(folded.unicodeScalars.count)
-
-        let allowed = CharacterSet.alphanumerics
-        var previousWasDash = false
-        for scalar in folded.unicodeScalars {
-            if allowed.contains(scalar) {
-                scalarBuffer.append(UnicodeScalar(String(scalar).lowercased()) ?? scalar)
-                previousWasDash = false
-            } else if !previousWasDash {
-                scalarBuffer.append("-")
-                previousWasDash = true
-            }
-        }
-
-        var slug = String(String.UnicodeScalarView(scalarBuffer))
-        while slug.hasPrefix("-") {
-            slug.removeFirst()
-        }
-        while slug.hasSuffix("-") {
-            slug.removeLast()
-        }
-        return slug
-    }
-
-    private static func firstPathLikeValue(candidates: [String?]) -> String? {
-        for candidate in candidates {
-            guard let candidate else { continue }
-            if candidate.contains("/") || candidate.contains("\\") {
-                return candidate
-            }
-        }
-        return nil
-    }
-
-    private static func stablePathHash(_ value: String) -> String {
-        let normalized = value.lowercased()
-        var hash: UInt64 = 0xcbf29ce484222325
-        for byte in normalized.utf8 {
-            hash ^= UInt64(byte)
-            hash = hash &* 0x100000001b3
-        }
-        return String(format: "%016llx", hash)
-    }
-}

package/Sources/RunicCore/UsagePace.swift

@@ -1,81 +0,0 @@
-import Foundation
-
-public struct UsagePace: Sendable {
-    public enum Stage: Sendable {
-        case onTrack
-        case slightlyAhead
-        case ahead
-        case farAhead
-        case slightlyBehind
-        case behind
-        case farBehind
-    }
-
-    public let stage: Stage
-    public let deltaPercent: Double
-    public let expectedUsedPercent: Double
-    public let actualUsedPercent: Double
-    public let etaSeconds: TimeInterval?
-    public let willLastToReset: Bool
-
-    public static func weekly(
-        window: RateWindow,
-        now: Date = .init(),
-        defaultWindowMinutes: Int = 10080) -> UsagePace?
-    {
-        guard let resetsAt = window.resetsAt else { return nil }
-        let minutes = window.windowMinutes ?? defaultWindowMinutes
-        guard minutes > 0 else { return nil }
-
-        let duration = TimeInterval(minutes) * 60
-        let timeUntilReset = resetsAt.timeIntervalSince(now)
-        guard timeUntilReset > 0 else { return nil }
-        guard timeUntilReset <= duration else { return nil }
-        let elapsed = Self.clamp(duration - timeUntilReset, lower: 0, upper: duration)
-        let expected = Self.clamp((elapsed / duration) * 100, lower: 0, upper: 100)
-        let actual = Self.clamp(window.usedPercent, lower: 0, upper: 100)
-        if elapsed == 0, actual > 0 {
-            return nil
-        }
-        let delta = actual - expected
-        let stage = Self.stage(for: delta)
-
-        var etaSeconds: TimeInterval?
-        var willLastToReset = false
-
-        if elapsed > 0, actual > 0 {
-            let rate = actual / elapsed
-            if rate > 0 {
-                let remaining = max(0, 100 - actual)
-                let candidate = remaining / rate
-                if candidate >= timeUntilReset {
-                    willLastToReset = true
-                } else {
-                    etaSeconds = candidate
-                }
-            }
-        } else if elapsed > 0, actual == 0 {
-            willLastToReset = true
-        }
-
-        return UsagePace(
-            stage: stage,
-            deltaPercent: delta,
-            expectedUsedPercent: expected,
-            actualUsedPercent: actual,
-            etaSeconds: etaSeconds,
-            willLastToReset: willLastToReset)
-    }
-
-    private static func stage(for delta: Double) -> Stage {
-        let absDelta = abs(delta)
-        if absDelta <= 2 { return .onTrack }
-        if absDelta <= 6 { return delta >= 0 ? .slightlyAhead : .slightlyBehind }
-        if absDelta <= 12 { return delta >= 0 ? .ahead : .behind }
-        return delta >= 0 ? .farAhead : .farBehind
-    }
-
-    private static func clamp(_ value: Double, lower: Double, upper: Double) -> Double {
-        min(upper, max(lower, value))
-    }
-}

package/Sources/RunicCore/Vendored/CostUsage/CostUsageCache.swift

@@ -1,73 +0,0 @@
-import Foundation
-
-enum CostUsageCacheIO {
-    private static func defaultCacheRoot() -> URL {
-        let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
-        return root.appendingPathComponent("Runic", isDirectory: true)
-    }
-
-    static func cacheFileURL(provider: UsageProvider, cacheRoot: URL? = nil) -> URL {
-        let root = cacheRoot ?? self.defaultCacheRoot()
-        return root
-            .appendingPathComponent("cost-usage", isDirectory: true)
-            .appendingPathComponent("\(provider.rawValue)-v1.json", isDirectory: false)
-    }
-
-    static func load(provider: UsageProvider, cacheRoot: URL? = nil) -> CostUsageCache {
-        let url = self.cacheFileURL(provider: provider, cacheRoot: cacheRoot)
-        if let decoded = self.loadCache(at: url) { return decoded }
-        return CostUsageCache()
-    }
-
-    private static func loadCache(at url: URL) -> CostUsageCache? {
-        guard let data = try? Data(contentsOf: url) else { return nil }
-        guard let decoded = try? JSONDecoder().decode(CostUsageCache.self, from: data)
-        else { return nil }
-        guard decoded.version == 1 else { return nil }
-        return decoded
-    }
-
-    static func save(provider: UsageProvider, cache: CostUsageCache, cacheRoot: URL? = nil) {
-        let url = self.cacheFileURL(provider: provider, cacheRoot: cacheRoot)
-        let dir = url.deletingLastPathComponent()
-        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-
-        let tmp = dir.appendingPathComponent(".tmp-\(UUID().uuidString).json", isDirectory: false)
-        let data = (try? JSONEncoder().encode(cache)) ?? Data()
-        do {
-            try data.write(to: tmp, options: [.atomic])
-            _ = try FileManager.default.replaceItemAt(url, withItemAt: tmp)
-        } catch {
-            try? FileManager.default.removeItem(at: tmp)
-        }
-    }
-}
-
-struct CostUsageCache: Codable, Sendable {
-    var version: Int = 1
-    var lastScanUnixMs: Int64 = 0
-
-    // filePath -> file usage
-    var files: [String: CostUsageFileUsage] = [:]
-
-    // dayKey -> model -> packed usage
-    var days: [String: [String: [Int]]] = [:]
-
-    // rootPath -> mtime (for Claude roots)
-    var roots: [String: Int64]?
-}
-
-struct CostUsageFileUsage: Codable, Sendable {
-    var mtimeUnixMs: Int64
-    var size: Int64
-    var days: [String: [String: [Int]]]
-    var parsedBytes: Int64?
-    var lastModel: String?
-    var lastTotals: CostUsageCodexTotals?
-}
-
-struct CostUsageCodexTotals: Codable, Sendable {
-    var input: Int
-    var cached: Int
-    var output: Int
-}

package/Sources/RunicCore/Vendored/CostUsage/CostUsageJsonl.swift

@@ -1,74 +0,0 @@
-import Foundation
-
-enum CostUsageJsonl {
-    struct Line: Sendable {
-        let bytes: Data
-        let wasTruncated: Bool
-    }
-
-    @discardableResult
-    static func scan(
-        fileURL: URL,
-        offset: Int64 = 0,
-        maxLineBytes: Int,
-        prefixBytes: Int,
-        onLine: (Line) -> Void) throws
-        -> Int64
-    {
-        let handle = try FileHandle(forReadingFrom: fileURL)
-        defer { try? handle.close() }
-
-        let startOffset = max(0, offset)
-        if startOffset > 0 {
-            try handle.seek(toOffset: UInt64(startOffset))
-        }
-
-        var buffer = Data()
-        buffer.reserveCapacity(64 * 1024)
-
-        var current = Data()
-        current.reserveCapacity(4 * 1024)
-        var lineBytes = 0
-        var truncated = false
-        var bytesRead: Int64 = 0
-
-        func flushLine() {
-            guard lineBytes > 0 else { return }
-            let line = Line(bytes: current, wasTruncated: truncated)
-            onLine(line)
-            current.removeAll(keepingCapacity: true)
-            lineBytes = 0
-            truncated = false
-        }
-
-        while true {
-            let chunk = try handle.read(upToCount: 256 * 1024) ?? Data()
-            if chunk.isEmpty {
-                flushLine()
-                break
-            }
-
-            bytesRead += Int64(chunk.count)
-            buffer.append(chunk)
-
-            while true {
-                guard let nl = buffer.firstIndex(of: 0x0A) else { break }
-                let linePart = buffer[..<nl]
-                buffer.removeSubrange(...nl)
-
-                lineBytes += linePart.count
-                if !truncated {
-                    if lineBytes > maxLineBytes || lineBytes > prefixBytes {
-                        truncated = true
-                        current.removeAll(keepingCapacity: true)
-                    } else {
-                        current.append(contentsOf: linePart)
-                    }
-                }
-                flushLine()
-            }
-        }
-
-        return startOffset + bytesRead
-    }
-}

package/Sources/RunicCore/Vendored/CostUsage/CostUsagePricing.swift

@@ -1,208 +0,0 @@
-import Foundation
-
-enum CostUsagePricing {
-    struct CodexPricing: Sendable {
-        let inputCostPerToken: Double
-        let outputCostPerToken: Double
-        let cacheReadInputCostPerToken: Double
-    }
-
-    struct ClaudePricing: Sendable {
-        let inputCostPerToken: Double
-        let outputCostPerToken: Double
-        let cacheCreationInputCostPerToken: Double
-        let cacheReadInputCostPerToken: Double
-
-        let thresholdTokens: Int?
-        let inputCostPerTokenAboveThreshold: Double?
-        let outputCostPerTokenAboveThreshold: Double?
-        let cacheCreationInputCostPerTokenAboveThreshold: Double?
-        let cacheReadInputCostPerTokenAboveThreshold: Double?
-    }
-
-    private static let codex: [String: CodexPricing] = [
-        "gpt-5": CodexPricing(
-            inputCostPerToken: 1.25e-6,
-            outputCostPerToken: 1e-5,
-            cacheReadInputCostPerToken: 1.25e-7),
-        "gpt-5-codex": CodexPricing(
-            inputCostPerToken: 1.25e-6,
-            outputCostPerToken: 1e-5,
-            cacheReadInputCostPerToken: 1.25e-7),
-        "gpt-5.1": CodexPricing(
-            inputCostPerToken: 1.25e-6,
-            outputCostPerToken: 1e-5,
-            cacheReadInputCostPerToken: 1.25e-7),
-        "gpt-5.2": CodexPricing(
-            inputCostPerToken: 1.75e-6,
-            outputCostPerToken: 1.4e-5,
-            cacheReadInputCostPerToken: 1.75e-7),
-        "gpt-5.2-codex": CodexPricing(
-            inputCostPerToken: 1.75e-6,
-            outputCostPerToken: 1.4e-5,
-            cacheReadInputCostPerToken: 1.75e-7),
-    ]
-
-    private static let claude: [String: ClaudePricing] = [
-        "claude-haiku-4-5-20251001": ClaudePricing(
-            inputCostPerToken: 1e-6,
-            outputCostPerToken: 5e-6,
-            cacheCreationInputCostPerToken: 1.25e-6,
-            cacheReadInputCostPerToken: 1e-7,
-            thresholdTokens: nil,
-            inputCostPerTokenAboveThreshold: nil,
-            outputCostPerTokenAboveThreshold: nil,
-            cacheCreationInputCostPerTokenAboveThreshold: nil,
-            cacheReadInputCostPerTokenAboveThreshold: nil),
-        "claude-opus-4-5-20251101": ClaudePricing(
-            inputCostPerToken: 5e-6,
-            outputCostPerToken: 2.5e-5,
-            cacheCreationInputCostPerToken: 6.25e-6,
-            cacheReadInputCostPerToken: 5e-7,
-            thresholdTokens: nil,
-            inputCostPerTokenAboveThreshold: nil,
-            outputCostPerTokenAboveThreshold: nil,
-            cacheCreationInputCostPerTokenAboveThreshold: nil,
-            cacheReadInputCostPerTokenAboveThreshold: nil),
-        "claude-sonnet-4-5": ClaudePricing(
-            inputCostPerToken: 3e-6,
-            outputCostPerToken: 1.5e-5,
-            cacheCreationInputCostPerToken: 3.75e-6,
-            cacheReadInputCostPerToken: 3e-7,
-            thresholdTokens: 200_000,
-            inputCostPerTokenAboveThreshold: 6e-6,
-            outputCostPerTokenAboveThreshold: 2.25e-5,
-            cacheCreationInputCostPerTokenAboveThreshold: 7.5e-6,
-            cacheReadInputCostPerTokenAboveThreshold: 6e-7),
-        "claude-sonnet-4-5-20250929": ClaudePricing(
-            inputCostPerToken: 3e-6,
-            outputCostPerToken: 1.5e-5,
-            cacheCreationInputCostPerToken: 3.75e-6,
-            cacheReadInputCostPerToken: 3e-7,
-            thresholdTokens: 200_000,
-            inputCostPerTokenAboveThreshold: 6e-6,
-            outputCostPerTokenAboveThreshold: 2.25e-5,
-            cacheCreationInputCostPerTokenAboveThreshold: 7.5e-6,
-            cacheReadInputCostPerTokenAboveThreshold: 6e-7),
-        "claude-opus-4-20250514": ClaudePricing(
-            inputCostPerToken: 1.5e-5,
-            outputCostPerToken: 7.5e-5,
-            cacheCreationInputCostPerToken: 1.875e-5,
-            cacheReadInputCostPerToken: 1.5e-6,
-            thresholdTokens: nil,
-            inputCostPerTokenAboveThreshold: nil,
-            outputCostPerTokenAboveThreshold: nil,
-            cacheCreationInputCostPerTokenAboveThreshold: nil,
-            cacheReadInputCostPerTokenAboveThreshold: nil),
-        "claude-opus-4-1": ClaudePricing(
-            inputCostPerToken: 1.5e-5,
-            outputCostPerToken: 7.5e-5,
-            cacheCreationInputCostPerToken: 1.875e-5,
-            cacheReadInputCostPerToken: 1.5e-6,
-            thresholdTokens: nil,
-            inputCostPerTokenAboveThreshold: nil,
-            outputCostPerTokenAboveThreshold: nil,
-            cacheCreationInputCostPerTokenAboveThreshold: nil,
-            cacheReadInputCostPerTokenAboveThreshold: nil),
-        "claude-sonnet-4-20250514": ClaudePricing(
-            inputCostPerToken: 3e-6,
-            outputCostPerToken: 1.5e-5,
-            cacheCreationInputCostPerToken: 3.75e-6,
-            cacheReadInputCostPerToken: 3e-7,
-            thresholdTokens: 200_000,
-            inputCostPerTokenAboveThreshold: 6e-6,
-            outputCostPerTokenAboveThreshold: 2.25e-5,
-            cacheCreationInputCostPerTokenAboveThreshold: 7.5e-6,
-            cacheReadInputCostPerTokenAboveThreshold: 6e-7),
-    ]
-
-    static func normalizeCodexModel(_ raw: String) -> String {
-        var trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
-        if trimmed.hasPrefix("openai/") {
-            trimmed = String(trimmed.dropFirst("openai/".count))
-        }
-        if let codexRange = trimmed.range(of: "-codex") {
-            let base = String(trimmed[..<codexRange.lowerBound])
-            if self.codex[base] != nil { return base }
-        }
-        return trimmed
-    }
-
-    static func normalizeClaudeModel(_ raw: String) -> String {
-        var trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
-        if trimmed.hasPrefix("anthropic.") {
-            trimmed = String(trimmed.dropFirst("anthropic.".count))
-        }
-
-        if let lastDot = trimmed.lastIndex(of: "."),
-           trimmed.contains("claude-")
-        {
-            let tail = String(trimmed[trimmed.index(after: lastDot)...])
-            if tail.hasPrefix("claude-") {
-                trimmed = tail
-            }
-        }
-
-        if let vRange = trimmed.range(of: #"-v\d+:\d+$"#, options: .regularExpression) {
-            trimmed.removeSubrange(vRange)
-        }
-
-        if let baseRange = trimmed.range(of: #"-\d{8}$"#, options: .regularExpression) {
-            let base = String(trimmed[..<baseRange.lowerBound])
-            if self.claude[base] != nil {
-                return base
-            }
-        }
-
-        return trimmed
-    }
-
-    static func codexCostUSD(model: String, inputTokens: Int, cachedInputTokens: Int, outputTokens: Int) -> Double? {
-        let key = self.normalizeCodexModel(model)
-        guard let pricing = self.codex[key] else { return nil }
-        let cached = min(max(0, cachedInputTokens), max(0, inputTokens))
-        let nonCached = max(0, inputTokens - cached)
-        return Double(nonCached) * pricing.inputCostPerToken
-            + Double(cached) * pricing.cacheReadInputCostPerToken
-            + Double(max(0, outputTokens)) * pricing.outputCostPerToken
-    }
-
-    static func claudeCostUSD(
-        model: String,
-        inputTokens: Int,
-        cacheReadInputTokens: Int,
-        cacheCreationInputTokens: Int,
-        outputTokens: Int) -> Double?
-    {
-        let key = self.normalizeClaudeModel(model)
-        guard let pricing = self.claude[key] else { return nil }
-
-        func tiered(_ tokens: Int, base: Double, above: Double?, threshold: Int?) -> Double {
-            guard let threshold, let above else { return Double(tokens) * base }
-            let below = min(tokens, threshold)
-            let over = max(tokens - threshold, 0)
-            return Double(below) * base + Double(over) * above
-        }
-
-        return tiered(
-            max(0, inputTokens),
-            base: pricing.inputCostPerToken,
-            above: pricing.inputCostPerTokenAboveThreshold,
-            threshold: pricing.thresholdTokens)
-            + tiered(
-                max(0, cacheReadInputTokens),
-                base: pricing.cacheReadInputCostPerToken,
-                above: pricing.cacheReadInputCostPerTokenAboveThreshold,
-                threshold: pricing.thresholdTokens)
-            + tiered(
-                max(0, cacheCreationInputTokens),
-                base: pricing.cacheCreationInputCostPerToken,
-                above: pricing.cacheCreationInputCostPerTokenAboveThreshold,
-                threshold: pricing.thresholdTokens)
-            + tiered(
-                max(0, outputTokens),
-                base: pricing.outputCostPerToken,
-                above: pricing.outputCostPerTokenAboveThreshold,
-                threshold: pricing.thresholdTokens)
-    }
-}