wehub-resource-sync
433 lines
15 KiB
Swift
433 lines
15 KiB
Swift
import Foundation
|
|
#if canImport(FoundationNetworking)
|
|
import FoundationNetworking
|
|
#endif
|
|
|
|
// MARK: - API response types
|
|
|
|
public struct DeepSeekBalanceResponse: Decodable, Sendable {
|
|
public let isAvailable: Bool
|
|
public let balanceInfos: [DeepSeekBalanceInfo]
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case isAvailable = "is_available"
|
|
case balanceInfos = "balance_infos"
|
|
}
|
|
}
|
|
|
|
public struct DeepSeekBalanceInfo: Decodable, Sendable {
|
|
public let currency: String
|
|
public let totalBalance: String
|
|
public let grantedBalance: String
|
|
public let toppedUpBalance: String
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case currency
|
|
case totalBalance = "total_balance"
|
|
case grantedBalance = "granted_balance"
|
|
case toppedUpBalance = "topped_up_balance"
|
|
}
|
|
}
|
|
|
|
// MARK: - Domain snapshot
|
|
|
|
public struct DeepSeekUsageSnapshot: Sendable {
|
|
public let isAvailable: Bool
|
|
public let currency: String
|
|
public let totalBalance: Double
|
|
public let grantedBalance: Double
|
|
public let toppedUpBalance: Double
|
|
public let usageSummary: DeepSeekUsageSummary?
|
|
public let updatedAt: Date
|
|
|
|
public init(
|
|
isAvailable: Bool,
|
|
currency: String,
|
|
totalBalance: Double,
|
|
grantedBalance: Double,
|
|
toppedUpBalance: Double,
|
|
usageSummary: DeepSeekUsageSummary? = nil,
|
|
updatedAt: Date)
|
|
{
|
|
self.isAvailable = isAvailable
|
|
self.currency = currency
|
|
self.totalBalance = totalBalance
|
|
self.grantedBalance = grantedBalance
|
|
self.toppedUpBalance = toppedUpBalance
|
|
self.usageSummary = usageSummary
|
|
self.updatedAt = updatedAt
|
|
}
|
|
|
|
public func toUsageSnapshot() -> UsageSnapshot {
|
|
let symbol = self.currency == "CNY" ? "¥" : "$"
|
|
|
|
let balanceDetail: String
|
|
let usedPercent: Double
|
|
if self.totalBalance <= 0 {
|
|
balanceDetail = "\(symbol)0.00 — add credits at platform.deepseek.com"
|
|
usedPercent = 100
|
|
} else if !self.isAvailable {
|
|
balanceDetail = "Balance unavailable for API calls"
|
|
usedPercent = 100
|
|
} else {
|
|
let total = String(format: "\(symbol)%.2f", self.totalBalance)
|
|
let paid = String(format: "\(symbol)%.2f", self.toppedUpBalance)
|
|
let granted = String(format: "\(symbol)%.2f", self.grantedBalance)
|
|
balanceDetail = "\(total) (Paid: \(paid) / Granted: \(granted))"
|
|
usedPercent = 0
|
|
}
|
|
|
|
let identity = ProviderIdentitySnapshot(
|
|
providerID: .deepseek,
|
|
accountEmail: nil,
|
|
accountOrganization: nil,
|
|
loginMethod: nil)
|
|
let balanceWindow = RateWindow(
|
|
usedPercent: usedPercent,
|
|
windowMinutes: nil,
|
|
resetsAt: nil,
|
|
resetDescription: balanceDetail)
|
|
|
|
return UsageSnapshot(
|
|
primary: balanceWindow,
|
|
secondary: nil,
|
|
tertiary: nil,
|
|
providerCost: nil,
|
|
deepseekUsage: self.usageSummary,
|
|
updatedAt: self.updatedAt,
|
|
identity: identity)
|
|
}
|
|
}
|
|
|
|
// MARK: - Errors
|
|
|
|
public enum DeepSeekUsageError: LocalizedError, Sendable {
|
|
case missingCredentials
|
|
case networkError(String)
|
|
case apiError(String)
|
|
case parseFailed(String)
|
|
|
|
public var errorDescription: String? {
|
|
switch self {
|
|
case .missingCredentials:
|
|
"Missing DeepSeek API key."
|
|
case let .networkError(message):
|
|
"DeepSeek network error: \(message)"
|
|
case let .apiError(message):
|
|
"DeepSeek API error: \(message)"
|
|
case let .parseFailed(message):
|
|
"Failed to parse DeepSeek response: \(message)"
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Fetcher
|
|
|
|
public struct DeepSeekUsageFetcher: Sendable {
|
|
private static let log = CodexBarLog.logger(LogCategories.deepSeekUsage)
|
|
private static let balanceURL = URL(string: "https://api.deepseek.com/user/balance")!
|
|
private static let usageAmountURL = URL(string: "https://platform.deepseek.com/api/v0/usage/amount")!
|
|
private static let usageCostURL = URL(string: "https://platform.deepseek.com/api/v0/usage/cost")!
|
|
private static let timeoutSeconds: TimeInterval = 15
|
|
private static let optionalSummaryJoinGrace: Duration = .seconds(2)
|
|
private static var apiCalendar: Calendar {
|
|
var calendar = Calendar(identifier: .gregorian)
|
|
calendar.locale = Locale(identifier: "en_US_POSIX")
|
|
calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? .gmt
|
|
return calendar
|
|
}
|
|
|
|
public static func fetchUsage(
|
|
apiKey: String,
|
|
includeOptionalUsage: Bool = true) async throws -> DeepSeekUsageSnapshot
|
|
{
|
|
try await self.fetchUsage(
|
|
apiKey: apiKey,
|
|
includeOptionalUsage: includeOptionalUsage,
|
|
optionalSummaryJoinGrace: self.optionalSummaryJoinGrace,
|
|
fetchBalanceData: { key in
|
|
try await self.fetchBalanceData(apiKey: key)
|
|
},
|
|
fetchSummary: { key in
|
|
try await self.fetchUsageSummary(apiKey: key)
|
|
})
|
|
}
|
|
|
|
static func _fetchUsageForTesting(
|
|
apiKey: String,
|
|
includeOptionalUsage: Bool,
|
|
optionalSummaryJoinGrace: Duration = .zero,
|
|
fetchBalanceData: @escaping @Sendable (String) async throws -> Data,
|
|
fetchSummary: @escaping @Sendable (String) async throws -> DeepSeekUsageSummary)
|
|
async throws -> DeepSeekUsageSnapshot
|
|
{
|
|
try await self.fetchUsage(
|
|
apiKey: apiKey,
|
|
includeOptionalUsage: includeOptionalUsage,
|
|
optionalSummaryJoinGrace: optionalSummaryJoinGrace,
|
|
fetchBalanceData: fetchBalanceData,
|
|
fetchSummary: fetchSummary)
|
|
}
|
|
|
|
private static func fetchUsage(
|
|
apiKey: String,
|
|
includeOptionalUsage: Bool,
|
|
optionalSummaryJoinGrace: Duration,
|
|
fetchBalanceData: @escaping @Sendable (String) async throws -> Data,
|
|
fetchSummary: @escaping @Sendable (String) async throws -> DeepSeekUsageSummary)
|
|
async throws -> DeepSeekUsageSnapshot
|
|
{
|
|
guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
|
|
throw DeepSeekUsageError.missingCredentials
|
|
}
|
|
|
|
let summaryTask: Task<DeepSeekUsageSummary, Error>? = if includeOptionalUsage {
|
|
Task {
|
|
try await fetchSummary(apiKey)
|
|
}
|
|
} else {
|
|
nil
|
|
}
|
|
|
|
let balanceData: Data
|
|
do {
|
|
balanceData = try await withTaskCancellationHandler {
|
|
try await fetchBalanceData(apiKey)
|
|
} onCancel: {
|
|
summaryTask?.cancel()
|
|
}
|
|
} catch {
|
|
summaryTask?.cancel()
|
|
throw error
|
|
}
|
|
var snapshot: DeepSeekUsageSnapshot
|
|
do {
|
|
snapshot = try Self.parseSnapshot(data: balanceData)
|
|
} catch {
|
|
summaryTask?.cancel()
|
|
throw error
|
|
}
|
|
|
|
if let summaryTask {
|
|
let summary = try await self.completedOptionalUsageSummary(
|
|
from: summaryTask,
|
|
joinGrace: optionalSummaryJoinGrace)
|
|
if let summary {
|
|
snapshot = DeepSeekUsageSnapshot(
|
|
isAvailable: snapshot.isAvailable,
|
|
currency: snapshot.currency,
|
|
totalBalance: snapshot.totalBalance,
|
|
grantedBalance: snapshot.grantedBalance,
|
|
toppedUpBalance: snapshot.toppedUpBalance,
|
|
usageSummary: summary,
|
|
updatedAt: snapshot.updatedAt)
|
|
}
|
|
}
|
|
|
|
return snapshot
|
|
}
|
|
|
|
private static func fetchBalanceData(apiKey: String) async throws -> Data {
|
|
var request = URLRequest(url: self.balanceURL)
|
|
request.httpMethod = "GET"
|
|
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
|
|
request.setValue("application/json", forHTTPHeaderField: "Accept")
|
|
request.timeoutInterval = Self.timeoutSeconds
|
|
|
|
let response = try await ProviderHTTPClient.shared.response(for: request)
|
|
let data = response.data
|
|
guard response.statusCode == 200 else {
|
|
Self.log.error("DeepSeek balance endpoint returned HTTP \(response.statusCode)")
|
|
throw DeepSeekUsageError.apiError("HTTP \(response.statusCode)")
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
private static func completedOptionalUsageSummary(
|
|
from task: Task<DeepSeekUsageSummary, Error>,
|
|
joinGrace: Duration) async throws -> DeepSeekUsageSummary?
|
|
{
|
|
let race = BoundedTaskJoin(sourceTask: task)
|
|
switch await race.value(joinGrace: joinGrace) {
|
|
case let .value(summary):
|
|
try Task.checkCancellation()
|
|
return summary
|
|
case .timedOut:
|
|
try Task.checkCancellation()
|
|
return nil
|
|
case let .failure(error):
|
|
task.cancel()
|
|
if Task.isCancelled {
|
|
throw error
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
static func _parseSnapshotForTesting(_ data: Data) throws -> DeepSeekUsageSnapshot {
|
|
try self.parseSnapshot(data: data)
|
|
}
|
|
|
|
public static func fetchUsageSummary(
|
|
apiKey: String,
|
|
now: Date = Date(),
|
|
calendar: Calendar? = nil) async throws -> DeepSeekUsageSummary
|
|
{
|
|
let calendar = calendar ?? self.apiCalendar
|
|
let period = try self.usagePeriod(now: now, calendar: calendar)
|
|
|
|
let amountData = try await self.fetchAmount(apiKey: apiKey, month: period.month, year: period.year)
|
|
let costData = try await self.fetchCost(apiKey: apiKey, month: period.month, year: period.year)
|
|
|
|
return try DeepSeekUsageCostParser.parse(
|
|
amountData: amountData,
|
|
costData: costData,
|
|
now: now,
|
|
calendar: calendar)
|
|
}
|
|
|
|
static func _apiUsagePeriodForTesting(now: Date, calendar: Calendar? = nil) throws -> (month: Int, year: Int) {
|
|
try self.usagePeriod(now: now, calendar: calendar ?? self.apiCalendar)
|
|
}
|
|
|
|
private static func usagePeriod(now: Date, calendar: Calendar) throws -> (month: Int, year: Int) {
|
|
let monthComponents = calendar.dateComponents([.month, .year], from: now)
|
|
guard let month = monthComponents.month, let year = monthComponents.year else {
|
|
throw DeepSeekUsageError.parseFailed("Could not determine current month/year")
|
|
}
|
|
return (month: month, year: year)
|
|
}
|
|
|
|
private static func fetchAmount(apiKey: String, month: Int, year: Int) async throws -> Data {
|
|
guard var components = URLComponents(url: self.usageAmountURL, resolvingAgainstBaseURL: false) else {
|
|
throw DeepSeekUsageError.networkError("Invalid URL")
|
|
}
|
|
components.queryItems = [
|
|
URLQueryItem(name: "month", value: String(month)),
|
|
URLQueryItem(name: "year", value: String(year)),
|
|
]
|
|
guard let url = components.url else {
|
|
throw DeepSeekUsageError.networkError("Could not construct URL")
|
|
}
|
|
|
|
var request = URLRequest(url: url)
|
|
request.httpMethod = "GET"
|
|
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
|
|
request.setValue("application/json", forHTTPHeaderField: "Accept")
|
|
request.timeoutInterval = Self.timeoutSeconds
|
|
|
|
let response = try await ProviderHTTPClient.shared.response(for: request)
|
|
let data = response.data
|
|
guard response.statusCode == 200 else {
|
|
if response.statusCode == 401 || response.statusCode == 403 {
|
|
throw DeepSeekUsageError.missingCredentials
|
|
}
|
|
throw DeepSeekUsageError.apiError("HTTP \(response.statusCode)")
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
private static func fetchCost(apiKey: String, month: Int, year: Int) async throws -> Data {
|
|
guard var components = URLComponents(url: self.usageCostURL, resolvingAgainstBaseURL: false) else {
|
|
throw DeepSeekUsageError.networkError("Invalid URL")
|
|
}
|
|
components.queryItems = [
|
|
URLQueryItem(name: "month", value: String(month)),
|
|
URLQueryItem(name: "year", value: String(year)),
|
|
]
|
|
guard let url = components.url else {
|
|
throw DeepSeekUsageError.networkError("Could not construct URL")
|
|
}
|
|
|
|
var request = URLRequest(url: url)
|
|
request.httpMethod = "GET"
|
|
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
|
|
request.setValue("application/json", forHTTPHeaderField: "Accept")
|
|
request.timeoutInterval = Self.timeoutSeconds
|
|
|
|
let response = try await ProviderHTTPClient.shared.response(for: request)
|
|
let data = response.data
|
|
guard response.statusCode == 200 else {
|
|
if response.statusCode == 401 || response.statusCode == 403 {
|
|
throw DeepSeekUsageError.missingCredentials
|
|
}
|
|
throw DeepSeekUsageError.apiError("HTTP \(response.statusCode)")
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
static func _parseUsageSummaryForTesting(
|
|
amountData: Data,
|
|
costData: Data,
|
|
now: Date = Date(),
|
|
calendar: Calendar = .current) throws -> DeepSeekUsageSummary
|
|
{
|
|
try DeepSeekUsageCostParser.parse(
|
|
amountData: amountData,
|
|
costData: costData,
|
|
now: now,
|
|
calendar: calendar)
|
|
}
|
|
|
|
private static func parseSnapshot(data: Data) throws -> DeepSeekUsageSnapshot {
|
|
let decoded: DeepSeekBalanceResponse
|
|
do {
|
|
decoded = try JSONDecoder().decode(DeepSeekBalanceResponse.self, from: data)
|
|
} catch {
|
|
throw DeepSeekUsageError.parseFailed(error.localizedDescription)
|
|
}
|
|
|
|
let balances = try decoded.balanceInfos.map(Self.parseBalanceInfo)
|
|
guard !balances.isEmpty else {
|
|
return DeepSeekUsageSnapshot(
|
|
isAvailable: false,
|
|
currency: "USD",
|
|
totalBalance: 0,
|
|
grantedBalance: 0,
|
|
toppedUpBalance: 0,
|
|
updatedAt: Date())
|
|
}
|
|
|
|
// Prefer USD when it is funded, but do not hide a positive CNY balance behind
|
|
// an empty USD row returned by the API.
|
|
let selected = balances.first { $0.currency == "USD" && $0.totalBalance > 0 }
|
|
?? balances.first { $0.totalBalance > 0 }
|
|
?? balances.first { $0.currency == "USD" }
|
|
?? balances[0]
|
|
|
|
return DeepSeekUsageSnapshot(
|
|
isAvailable: decoded.isAvailable,
|
|
currency: selected.currency,
|
|
totalBalance: selected.totalBalance,
|
|
grantedBalance: selected.grantedBalance,
|
|
toppedUpBalance: selected.toppedUpBalance,
|
|
updatedAt: Date())
|
|
}
|
|
|
|
private struct ParsedBalanceInfo {
|
|
let currency: String
|
|
let totalBalance: Double
|
|
let grantedBalance: Double
|
|
let toppedUpBalance: Double
|
|
}
|
|
|
|
private static func parseBalanceInfo(_ info: DeepSeekBalanceInfo) throws -> ParsedBalanceInfo {
|
|
guard
|
|
let total = Double(info.totalBalance),
|
|
let granted = Double(info.grantedBalance),
|
|
let toppedUp = Double(info.toppedUpBalance)
|
|
else {
|
|
throw DeepSeekUsageError.parseFailed("Non-numeric balance value in response.")
|
|
}
|
|
|
|
return ParsedBalanceInfo(
|
|
currency: info.currency,
|
|
totalBalance: total,
|
|
grantedBalance: granted,
|
|
toppedUpBalance: toppedUp)
|
|
}
|
|
}
|