wehub-resource-sync
729 lines
24 KiB
Swift
729 lines
24 KiB
Swift
import Foundation
|
|
#if canImport(FoundationNetworking)
|
|
import FoundationNetworking
|
|
#endif
|
|
|
|
public struct SyntheticQuotaEntry: Sendable {
|
|
public let label: String?
|
|
public let usedPercent: Double
|
|
public let windowMinutes: Int?
|
|
public let resetsAt: Date?
|
|
public let resetDescription: String?
|
|
public let nextRegenPercent: Double?
|
|
public let cost: ProviderCostSnapshot?
|
|
|
|
public init(
|
|
label: String?,
|
|
usedPercent: Double,
|
|
windowMinutes: Int?,
|
|
resetsAt: Date?,
|
|
resetDescription: String?,
|
|
nextRegenPercent: Double? = nil,
|
|
cost: ProviderCostSnapshot? = nil)
|
|
{
|
|
self.label = label
|
|
self.usedPercent = usedPercent
|
|
self.windowMinutes = windowMinutes
|
|
self.resetsAt = resetsAt
|
|
self.resetDescription = resetDescription
|
|
self.nextRegenPercent = nextRegenPercent
|
|
self.cost = cost
|
|
}
|
|
}
|
|
|
|
public struct SyntheticUsageSnapshot: Sendable {
|
|
public let quotas: [SyntheticQuotaEntry]
|
|
/// Slot-identified lanes for the known Synthetic response shape: [rolling-5h, weekly, search-hourly].
|
|
/// When set, `toUsageSnapshot` maps slot 0 → primary, slot 1 → secondary, slot 2 → tertiary,
|
|
/// so a missing lane stays nil instead of promoting the next lane into the wrong UI label.
|
|
public let slottedQuotas: [SyntheticQuotaEntry?]?
|
|
public let planName: String?
|
|
public let updatedAt: Date
|
|
|
|
public init(
|
|
quotas: [SyntheticQuotaEntry],
|
|
slottedQuotas: [SyntheticQuotaEntry?]? = nil,
|
|
planName: String?,
|
|
updatedAt: Date)
|
|
{
|
|
self.quotas = quotas
|
|
self.slottedQuotas = slottedQuotas
|
|
self.planName = planName
|
|
self.updatedAt = updatedAt
|
|
}
|
|
}
|
|
|
|
extension SyntheticUsageSnapshot {
|
|
public func toUsageSnapshot() -> UsageSnapshot {
|
|
let slots = self.slottedQuotas
|
|
?? [self.quotas.first, self.quotas.dropFirst().first, self.quotas.dropFirst(2).first]
|
|
let entries: [SyntheticQuotaEntry?] = (0..<3).map { slots.indices.contains($0) ? slots[$0] : nil }
|
|
|
|
let primary = entries[0].map(Self.rateWindow(for:))
|
|
let secondary = entries[1].map(Self.rateWindow(for:))
|
|
let tertiary = entries[2].map(Self.rateWindow(for:))
|
|
|
|
let planName = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let loginMethod = (planName?.isEmpty ?? true) ? nil : planName
|
|
let identity = ProviderIdentitySnapshot(
|
|
providerID: .synthetic,
|
|
accountEmail: nil,
|
|
accountOrganization: nil,
|
|
loginMethod: loginMethod)
|
|
|
|
return UsageSnapshot(
|
|
primary: primary,
|
|
secondary: secondary,
|
|
tertiary: tertiary,
|
|
providerCost: self.quotas.first(where: { $0.cost != nil })?.cost,
|
|
updatedAt: self.updatedAt,
|
|
identity: identity)
|
|
}
|
|
|
|
private static func rateWindow(for quota: SyntheticQuotaEntry) -> RateWindow {
|
|
RateWindow(
|
|
usedPercent: quota.usedPercent,
|
|
windowMinutes: quota.windowMinutes,
|
|
resetsAt: quota.resetsAt,
|
|
resetDescription: quota.resetDescription,
|
|
nextRegenPercent: quota.nextRegenPercent)
|
|
}
|
|
}
|
|
|
|
public struct SyntheticUsageFetcher: Sendable {
|
|
private static let log = CodexBarLog.logger(LogCategories.syntheticUsage)
|
|
private static let quotaAPIURL = "https://api.synthetic.new/v2/quotas"
|
|
|
|
public static func fetchUsage(apiKey: String, now: Date = Date()) async throws -> SyntheticUsageSnapshot {
|
|
guard !apiKey.isEmpty else {
|
|
throw SyntheticUsageError.invalidCredentials
|
|
}
|
|
|
|
var request = URLRequest(url: URL(string: Self.quotaAPIURL)!)
|
|
request.httpMethod = "GET"
|
|
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
|
|
request.setValue("application/json", forHTTPHeaderField: "Accept")
|
|
|
|
let response = try await ProviderHTTPClient.shared.response(for: request)
|
|
let data = response.data
|
|
guard response.statusCode == 200 else {
|
|
let errorMessage = String(data: data, encoding: .utf8) ?? "Unknown error"
|
|
Self.log.error("Synthetic API returned \(response.statusCode): \(errorMessage)")
|
|
if response.statusCode == 401 || response.statusCode == 403 {
|
|
throw SyntheticUsageError.invalidCredentials
|
|
}
|
|
throw SyntheticUsageError.apiError("HTTP \(response.statusCode): \(errorMessage)")
|
|
}
|
|
|
|
do {
|
|
return try SyntheticUsageParser.parse(data: data, now: now)
|
|
} catch let error as SyntheticUsageError {
|
|
throw error
|
|
} catch {
|
|
Self.log.error("Synthetic parsing error: \(error.localizedDescription)")
|
|
throw SyntheticUsageError.parseFailed(error.localizedDescription)
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class SyntheticISO8601FormatterBox: @unchecked Sendable {
|
|
let lock = NSLock()
|
|
let withFractional: ISO8601DateFormatter = {
|
|
let formatter = ISO8601DateFormatter()
|
|
formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
|
|
return formatter
|
|
}()
|
|
|
|
let plain: ISO8601DateFormatter = {
|
|
let formatter = ISO8601DateFormatter()
|
|
formatter.formatOptions = [.withInternetDateTime]
|
|
return formatter
|
|
}()
|
|
}
|
|
|
|
private enum SyntheticTimestampParser {
|
|
static let box = SyntheticISO8601FormatterBox()
|
|
|
|
static func parse(_ text: String) -> Date? {
|
|
self.box.lock.lock()
|
|
defer { self.box.lock.unlock() }
|
|
return self.box.withFractional.date(from: text) ?? self.box.plain.date(from: text)
|
|
}
|
|
}
|
|
|
|
enum SyntheticUsageParser {
|
|
static func parse(data: Data, now: Date = Date()) throws -> SyntheticUsageSnapshot {
|
|
let object = try JSONSerialization.jsonObject(with: data, options: [])
|
|
|
|
let root: [String: Any] = {
|
|
if let dict = object as? [String: Any] { return dict }
|
|
if let array = object as? [Any] { return ["quotas": array] }
|
|
return [:]
|
|
}()
|
|
|
|
let planName = self.planName(from: root)
|
|
|
|
if let slots = self.prioritizedQuotaSlots(from: root) {
|
|
let slotted: [SyntheticQuotaEntry?] = slots.map { $0.flatMap(self.parseQuota) }
|
|
let flat = slotted.compactMap(\.self)
|
|
guard !flat.isEmpty else {
|
|
throw SyntheticUsageError.parseFailed("Missing quota data.")
|
|
}
|
|
return SyntheticUsageSnapshot(
|
|
quotas: flat,
|
|
slottedQuotas: slotted,
|
|
planName: planName,
|
|
updatedAt: now)
|
|
}
|
|
|
|
let quotas = self.fallbackQuotaObjects(from: root).compactMap(self.parseQuota)
|
|
guard !quotas.isEmpty else {
|
|
throw SyntheticUsageError.parseFailed("Missing quota data.")
|
|
}
|
|
return SyntheticUsageSnapshot(
|
|
quotas: quotas,
|
|
planName: planName,
|
|
updatedAt: now)
|
|
}
|
|
|
|
/// Returns slot-positional quota payloads `[rolling-5h, weekly, search-hourly]` when the known Synthetic
|
|
/// response shape is detected. Missing lanes stay nil in their slot so downstream code doesn't shift
|
|
/// labels. Returns nil if none of the known keys appear, so the fallback path runs.
|
|
private static func prioritizedQuotaSlots(from root: [String: Any]) -> [[String: Any]?]? {
|
|
let dataDict = root["data"] as? [String: Any]
|
|
let rolling = self.namedQuota(root["rollingFiveHourLimit"], label: "Rolling five-hour limit")
|
|
?? self.namedQuota(dataDict?["rollingFiveHourLimit"], label: "Rolling five-hour limit")
|
|
let weekly = self.namedQuota(root["weeklyTokenLimit"], label: "Weekly token limit")
|
|
?? self.namedQuota(dataDict?["weeklyTokenLimit"], label: "Weekly token limit")
|
|
let searchHourly = self.namedQuota((root["search"] as? [String: Any])?["hourly"], label: "Search hourly")
|
|
?? self.namedQuota((dataDict?["search"] as? [String: Any])?["hourly"], label: "Search hourly")
|
|
let slots: [[String: Any]?] = [rolling, weekly, searchHourly]
|
|
return slots.contains(where: { $0 != nil }) ? slots : nil
|
|
}
|
|
|
|
private static func fallbackQuotaObjects(from root: [String: Any]) -> [[String: Any]] {
|
|
let dataDict = root["data"] as? [String: Any]
|
|
let candidates: [Any?] = [
|
|
root["quotas"],
|
|
root["quota"],
|
|
root["limits"],
|
|
root["usage"],
|
|
root["entries"],
|
|
root["subscription"],
|
|
root["data"],
|
|
dataDict?["quotas"],
|
|
dataDict?["quota"],
|
|
dataDict?["limits"],
|
|
dataDict?["usage"],
|
|
dataDict?["entries"],
|
|
dataDict?["subscription"],
|
|
]
|
|
|
|
for candidate in candidates {
|
|
let quotas = self.extractQuotaObjects(from: candidate)
|
|
if !quotas.isEmpty { return quotas }
|
|
}
|
|
return []
|
|
}
|
|
|
|
private static func planName(from root: [String: Any]) -> String? {
|
|
if let direct = self.firstString(in: root, keys: planKeys) { return direct }
|
|
if let dataDict = root["data"] as? [String: Any],
|
|
let plan = self.firstString(in: dataDict, keys: planKeys)
|
|
{
|
|
return plan
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func parseQuota(_ payload: [String: Any]) -> SyntheticQuotaEntry? {
|
|
let label = self.firstString(in: payload, keys: Self.labelKeys)
|
|
|
|
let percentUsed = self.normalizedPercent(
|
|
self.firstDouble(in: payload, keys: Self.percentUsedKeys))
|
|
let percentRemaining = self.normalizedPercent(
|
|
self.firstDouble(in: payload, keys: Self.percentRemainingKeys))
|
|
|
|
var usedPercent = percentUsed
|
|
if usedPercent == nil, let remaining = percentRemaining {
|
|
usedPercent = 100 - remaining
|
|
}
|
|
|
|
if usedPercent == nil {
|
|
var limit = self.firstDouble(in: payload, keys: Self.limitKeys)
|
|
var used = self.firstDouble(in: payload, keys: Self.usedKeys)
|
|
var remaining = self.firstDouble(in: payload, keys: Self.remainingKeys)
|
|
|
|
if limit == nil, let used, let remaining {
|
|
limit = used + remaining
|
|
}
|
|
if used == nil, let limit, let remaining {
|
|
used = limit - remaining
|
|
}
|
|
if remaining == nil, let limit, let used {
|
|
remaining = max(0, limit - used)
|
|
}
|
|
|
|
if let limit, let used, limit > 0 {
|
|
usedPercent = (used / limit) * 100
|
|
}
|
|
}
|
|
|
|
guard let usedPercent else { return nil }
|
|
let clamped = max(0, min(usedPercent, 100))
|
|
|
|
let windowMinutes = windowMinutes(from: payload)
|
|
let resetsAt = self.firstDate(in: payload, keys: self.resetKeys)
|
|
// Leave resetDescription nil when resetsAt is set so the UI rebuilds the countdown each render
|
|
// against the current clock instead of freezing a stale "in Xm" string at parse time.
|
|
let resetDescription = resetsAt == nil ? self.windowDescription(minutes: windowMinutes) : nil
|
|
|
|
let cost = self.providerCost(from: payload, usedPercent: clamped, resetsAt: resetsAt)
|
|
let nextRegenPercent = self.normalizedPercent(
|
|
self.firstDouble(in: payload, keys: Self.tickPercentKeys))
|
|
|
|
return SyntheticQuotaEntry(
|
|
label: label,
|
|
usedPercent: clamped,
|
|
windowMinutes: windowMinutes,
|
|
resetsAt: resetsAt,
|
|
resetDescription: resetDescription,
|
|
nextRegenPercent: nextRegenPercent,
|
|
cost: cost)
|
|
}
|
|
|
|
private static func isQuotaPayload(_ payload: [String: Any]) -> Bool {
|
|
let checks = [
|
|
Self.limitKeys,
|
|
Self.usedKeys,
|
|
Self.remainingKeys,
|
|
Self.percentUsedKeys,
|
|
Self.percentRemainingKeys,
|
|
]
|
|
return checks.contains { self.firstDouble(in: payload, keys: $0) != nil }
|
|
}
|
|
|
|
private static func windowMinutes(from payload: [String: Any]) -> Int? {
|
|
if let minutes = self.firstInt(in: payload, keys: windowMinutesKeys) { return minutes }
|
|
if let hours = self.firstDouble(in: payload, keys: windowHoursKeys) {
|
|
return Int((hours * 60).rounded())
|
|
}
|
|
if let days = self.firstDouble(in: payload, keys: windowDaysKeys) {
|
|
return Int((days * 24 * 60).rounded())
|
|
}
|
|
if let seconds = self.firstDouble(in: payload, keys: windowSecondsKeys) {
|
|
return Int((seconds / 60).rounded())
|
|
}
|
|
if let text = self.firstString(in: payload, keys: windowStringKeys) {
|
|
return self.windowMinutes(fromText: text)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func namedQuota(_ candidate: Any?, label: String) -> [String: Any]? {
|
|
guard var payload = candidate as? [String: Any], self.isQuotaPayload(payload) else { return nil }
|
|
if payload["label"] == nil, payload["name"] == nil {
|
|
payload["label"] = label
|
|
}
|
|
return payload
|
|
}
|
|
|
|
private static func extractQuotaObjects(from candidate: Any?) -> [[String: Any]] {
|
|
switch candidate {
|
|
case let array as [[String: Any]]:
|
|
var nestedQuotas: [[String: Any]] = []
|
|
for entry in array {
|
|
if self.isQuotaPayload(entry) {
|
|
nestedQuotas.append(entry)
|
|
} else {
|
|
nestedQuotas.append(contentsOf: self.extractQuotaObjects(from: entry))
|
|
}
|
|
}
|
|
return nestedQuotas
|
|
case let array as [Any]:
|
|
return array.flatMap { self.extractQuotaObjects(from: $0) }
|
|
case let dict as [String: Any]:
|
|
if self.isQuotaPayload(dict) {
|
|
return [dict]
|
|
}
|
|
var nestedQuotas: [[String: Any]] = []
|
|
for key in dict.keys.sorted() {
|
|
nestedQuotas.append(contentsOf: self.extractQuotaObjects(from: dict[key]))
|
|
}
|
|
return nestedQuotas
|
|
default:
|
|
return []
|
|
}
|
|
}
|
|
|
|
/// Parses durations like `"5hr"`, `"30min"`, `"2 days"`. Suffixes are sorted longest-first so
|
|
/// multi-letter units always win over their single-letter aliases — no ordering surprises if a
|
|
/// future unit shares a trailing letter with another.
|
|
static func windowMinutes(fromText text: String) -> Int? {
|
|
let normalized = text
|
|
.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
.lowercased()
|
|
.replacingOccurrences(of: " ", with: "")
|
|
guard !normalized.isEmpty else { return nil }
|
|
|
|
for (suffix, multiplier) in Self.windowSuffixMultipliers {
|
|
guard normalized.hasSuffix(suffix) else { continue }
|
|
let valueText = String(normalized.dropLast(suffix.count))
|
|
guard let value = Double(valueText), value > 0 else { return nil }
|
|
return Int((value * multiplier).rounded())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static let windowSuffixMultipliers: [(suffix: String, multiplier: Double)] = {
|
|
let raw: [(String, Double)] = [
|
|
("minutes", 1), ("minute", 1), ("mins", 1), ("min", 1), ("m", 1),
|
|
("hours", 60), ("hour", 60), ("hrs", 60), ("hr", 60), ("h", 60),
|
|
("days", 24 * 60), ("day", 24 * 60), ("d", 24 * 60),
|
|
]
|
|
return raw
|
|
.sorted { $0.0.count > $1.0.count }
|
|
.map { (suffix: $0.0, multiplier: $0.1) }
|
|
}()
|
|
|
|
private static func windowDescription(minutes: Int?) -> String? {
|
|
guard let minutes, minutes > 0 else { return nil }
|
|
let dayMinutes = 24 * 60
|
|
if minutes % dayMinutes == 0 {
|
|
let days = minutes / dayMinutes
|
|
return "\(days) day\(days == 1 ? "" : "s") window"
|
|
}
|
|
if minutes % 60 == 0 {
|
|
let hours = minutes / 60
|
|
return "\(hours) hour\(hours == 1 ? "" : "s") window"
|
|
}
|
|
return "\(minutes) minute\(minutes == 1 ? "" : "s") window"
|
|
}
|
|
|
|
private static func providerCost(
|
|
from payload: [String: Any],
|
|
usedPercent: Double,
|
|
resetsAt: Date?) -> ProviderCostSnapshot?
|
|
{
|
|
guard let limit = self.firstCurrency(in: payload, keys: self.costLimitKeys) else { return nil }
|
|
|
|
let remaining = self.firstCurrency(in: payload, keys: self.costRemainingKeys)
|
|
let usedFromPayload = self.firstCurrency(in: payload, keys: self.costUsedKeys)
|
|
let nextRegenAmount = self.firstCurrency(in: payload, keys: self.regenAmountKeys)
|
|
let used = if let usedFromPayload {
|
|
usedFromPayload
|
|
} else if let remaining {
|
|
max(0, limit - remaining)
|
|
} else {
|
|
(usedPercent.clamped(to: 0...100) / 100) * limit
|
|
}
|
|
|
|
return ProviderCostSnapshot(
|
|
used: used,
|
|
limit: limit,
|
|
currencyCode: "USD",
|
|
period: "Weekly",
|
|
resetsAt: resetsAt,
|
|
nextRegenAmount: nextRegenAmount,
|
|
updatedAt: Date())
|
|
}
|
|
|
|
private static func firstCurrency(in payload: [String: Any], keys: [String]) -> Double? {
|
|
for key in keys {
|
|
guard let value = payload[key] else { continue }
|
|
if let text = value as? String,
|
|
let parsed = self.parseCurrency(text)
|
|
{
|
|
return parsed
|
|
}
|
|
if let number = self.doubleValue(value) {
|
|
return number
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func parseCurrency(_ text: String) -> Double? {
|
|
let cleaned = text
|
|
.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
.replacingOccurrences(of: "$", with: "")
|
|
.replacingOccurrences(of: ",", with: "")
|
|
return Double(cleaned)
|
|
}
|
|
|
|
private static func normalizedPercent(_ value: Double?) -> Double? {
|
|
guard let value else { return nil }
|
|
if value <= 1 { return value * 100 }
|
|
return value
|
|
}
|
|
|
|
private static func firstString(in payload: [String: Any], keys: [String]) -> String? {
|
|
for key in keys {
|
|
if let value = self.stringValue(payload[key]) { return value }
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func firstDouble(in payload: [String: Any], keys: [String]) -> Double? {
|
|
for key in keys {
|
|
if let value = self.doubleValue(payload[key]) { return value }
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func firstInt(in payload: [String: Any], keys: [String]) -> Int? {
|
|
for key in keys {
|
|
if let value = self.intValue(payload[key]) { return value }
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func firstDate(in payload: [String: Any], keys: [String]) -> Date? {
|
|
for key in keys {
|
|
if let value = payload[key],
|
|
let date = self.dateValue(value)
|
|
{
|
|
return date
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func stringValue(_ raw: Any?) -> String? {
|
|
guard let raw else { return nil }
|
|
if let string = raw as? String {
|
|
let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
return trimmed.isEmpty ? nil : trimmed
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func doubleValue(_ raw: Any?) -> Double? {
|
|
switch raw {
|
|
case let number as Double:
|
|
return number
|
|
case let number as NSNumber:
|
|
return number.doubleValue
|
|
case let string as String:
|
|
let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
return Double(trimmed)
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private static func intValue(_ raw: Any?) -> Int? {
|
|
switch raw {
|
|
case let number as Int:
|
|
return number
|
|
case let number as NSNumber:
|
|
return number.intValue
|
|
case let string as String:
|
|
let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
return Int(trimmed)
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private static func dateValue(_ raw: Any) -> Date? {
|
|
if let number = self.doubleValue(raw) {
|
|
if number > 1_000_000_000_000 {
|
|
return Date(timeIntervalSince1970: number / 1000)
|
|
}
|
|
if number > 1_000_000_000 {
|
|
return Date(timeIntervalSince1970: number)
|
|
}
|
|
}
|
|
if let string = raw as? String {
|
|
if let number = Double(string.trimmingCharacters(in: .whitespacesAndNewlines)) {
|
|
return self.dateValue(number)
|
|
}
|
|
if let date = SyntheticTimestampParser.parse(string) {
|
|
return date
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static let planKeys = [
|
|
"plan",
|
|
"planName",
|
|
"plan_name",
|
|
"subscription",
|
|
"subscriptionPlan",
|
|
"tier",
|
|
"package",
|
|
"packageName",
|
|
]
|
|
|
|
private static let labelKeys = [
|
|
"name",
|
|
"label",
|
|
"type",
|
|
"period",
|
|
"scope",
|
|
"title",
|
|
"id",
|
|
]
|
|
|
|
private static let percentUsedKeys = [
|
|
"percentUsed",
|
|
"usedPercent",
|
|
"usagePercent",
|
|
"usage_percent",
|
|
"used_percent",
|
|
"percent_used",
|
|
"percent",
|
|
]
|
|
|
|
private static let percentRemainingKeys = [
|
|
"percentRemaining",
|
|
"remainingPercent",
|
|
"remaining_percent",
|
|
"percent_remaining",
|
|
]
|
|
|
|
private static let limitKeys = [
|
|
"limit",
|
|
"messageLimit",
|
|
"message_limit",
|
|
"messages",
|
|
"maxRequests",
|
|
"max_requests",
|
|
"requestLimit",
|
|
"request_limit",
|
|
"quota",
|
|
"max",
|
|
"total",
|
|
"capacity",
|
|
"allowance",
|
|
]
|
|
|
|
private static let usedKeys = [
|
|
"used",
|
|
"usage",
|
|
"usedMessages",
|
|
"used_messages",
|
|
"messagesUsed",
|
|
"messages_used",
|
|
"requests",
|
|
"requestCount",
|
|
"request_count",
|
|
"consumed",
|
|
"spent",
|
|
]
|
|
|
|
private static let remainingKeys = [
|
|
"remaining",
|
|
"left",
|
|
"available",
|
|
"balance",
|
|
]
|
|
|
|
private static let resetKeys = [
|
|
"resetAt",
|
|
"reset_at",
|
|
"resetsAt",
|
|
"resets_at",
|
|
"renewAt",
|
|
"renew_at",
|
|
"renewsAt",
|
|
"renews_at",
|
|
"nextTickAt",
|
|
"next_tick_at",
|
|
"nextRegenAt",
|
|
"next_regen_at",
|
|
"periodEnd",
|
|
"period_end",
|
|
"expiresAt",
|
|
"expires_at",
|
|
"endAt",
|
|
"end_at",
|
|
]
|
|
|
|
private static let regenAmountKeys = [
|
|
"nextRegenCredits",
|
|
"next_regen_credits",
|
|
]
|
|
|
|
private static let tickPercentKeys = [
|
|
"tickPercent",
|
|
"tick_percent",
|
|
"nextTickPercent",
|
|
"next_tick_percent",
|
|
]
|
|
|
|
private static let costLimitKeys = [
|
|
"maxCredits",
|
|
"max_credits",
|
|
]
|
|
|
|
private static let costRemainingKeys = [
|
|
"remainingCredits",
|
|
"remaining_credits",
|
|
]
|
|
|
|
private static let costUsedKeys = [
|
|
"usedCredits",
|
|
"used_credits",
|
|
]
|
|
|
|
private static let windowMinutesKeys = [
|
|
"windowMinutes",
|
|
"window_minutes",
|
|
"periodMinutes",
|
|
"period_minutes",
|
|
]
|
|
|
|
private static let windowHoursKeys = [
|
|
"windowHours",
|
|
"window_hours",
|
|
"periodHours",
|
|
"period_hours",
|
|
]
|
|
|
|
private static let windowDaysKeys = [
|
|
"windowDays",
|
|
"window_days",
|
|
"periodDays",
|
|
"period_days",
|
|
]
|
|
|
|
private static let windowSecondsKeys = [
|
|
"windowSeconds",
|
|
"window_seconds",
|
|
"periodSeconds",
|
|
"period_seconds",
|
|
]
|
|
|
|
private static let windowStringKeys = [
|
|
"window",
|
|
"windowLabel",
|
|
"window_label",
|
|
"period",
|
|
"periodLabel",
|
|
"period_label",
|
|
]
|
|
}
|
|
|
|
public enum SyntheticUsageError: LocalizedError, Sendable {
|
|
case invalidCredentials
|
|
case networkError(String)
|
|
case apiError(String)
|
|
case parseFailed(String)
|
|
|
|
public var errorDescription: String? {
|
|
switch self {
|
|
case .invalidCredentials:
|
|
"Invalid Synthetic API credentials"
|
|
case let .networkError(message):
|
|
"Synthetic network error: \(message)"
|
|
case let .apiError(message):
|
|
"Synthetic API error: \(message)"
|
|
case let .parseFailed(message):
|
|
"Failed to parse Synthetic response: \(message)"
|
|
}
|
|
}
|
|
}
|