@sriinnu/runic 1.0.0

package/Sources/RunicCore/UsageLedger/UsageLedgerProjectIdentity.swift

@@ -0,0 +1,245 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,208 @@
+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)
+    }
+}