@sriinnu/runic 2.0.0 → 2.11.2

package/Sources/RunicCore/Providers/Groq/GroqProviderDescriptor.swift

@@ -1,83 +0,0 @@
-import Foundation
-import RunicMacroSupport
-
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
-public enum GroqProviderDescriptor {
-    static func makeDescriptor() -> ProviderDescriptor {
-        ProviderDescriptor(
-            id: .groq,
-            metadata: ProviderMetadata(
-                id: .groq,
-                displayName: "Groq",
-                sessionLabel: "Models",
-                weeklyLabel: "",
-                opusLabel: nil,
-                supportsOpus: false,
-                supportsCredits: false,
-                creditsHint: "",
-                toggleTitle: "Show Groq usage",
-                cliName: "groq",
-                defaultEnabled: false,
-                isPrimaryProvider: false,
-                usesAccountFallback: false,
-                dashboardURL: "https://console.groq.com/usage",
-                statusPageURL: nil,
-                usageCoverage: ProviderUsageCoverage(
-                    supportsModelBreakdown: true,
-                    supportsTokenMetrics: false,
-                    supportsProjectAttribution: false)),
-            branding: ProviderBranding(
-                iconStyle: .groq,
-                iconResourceName: "ProviderIcon-groq",
-                color: ProviderColor(red: 0 / 255, green: 200 / 255, blue: 150 / 255)),
-            tokenCost: ProviderTokenCostConfig(
-                supportsTokenCost: false,
-                noDataMessage: { "Groq cost summary is not supported." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .cli],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [GroqAPIFetchStrategy()] })),
-            cli: ProviderCLIConfig(
-                name: "groq",
-                aliases: [],
-                versionDetector: nil))
-    }
-}
-
-struct GroqAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "groq.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveToken(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let apiKey = Self.resolveToken(environment: context.env) else {
-            throw GroqSettingsError.missingToken
-        }
-        let usage = try await GroqUsageFetcher.fetchModels(apiKey: apiKey)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: "api")
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveToken(environment: [String: String]) -> String? {
-        ProviderTokenResolver.groqToken(environment: environment)
-    }
-}
-
-enum GroqSettingsError: LocalizedError {
-    case missingToken
-
-    var errorDescription: String? {
-        switch self {
-        case .missingToken:
-            "Groq API key not found. Set it in Preferences → Providers → Groq or export GROQ_API_KEY."
-        }
-    }
-}

package/Sources/RunicCore/Providers/Groq/GroqUsageFetcher.swift

@@ -1,71 +0,0 @@
-import Foundation
-
-struct GroqModelsResponse: Decodable {
-    let data: [Model]?
-
-    struct Model: Decodable {
-        let id: String?
-    }
-}
-
-enum GroqUsageFetcher {
-    static let apiURL = URL(string: "https://api.groq.com/openai/v1/models")!
-
-    static func fetchModels(apiKey: String) async throws -> GroqModelsResponse {
-        var request = URLRequest(url: apiURL)
-        request.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
-        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw GroqAPIError.invalidResponse
-        }
-
-        guard httpResponse.statusCode == 200 else {
-            throw GroqAPIError.httpError(statusCode: httpResponse.statusCode)
-        }
-
-        let decoder = JSONDecoder()
-        return try decoder.decode(GroqModelsResponse.self, from: data)
-    }
-}
-
-extension GroqModelsResponse {
-    func toUsageSnapshot() -> UsageSnapshot {
-        let models = (self.data ?? []).compactMap(\.id)
-        var summary = "Models available: \(models.count)"
-        let preview = models.prefix(3).joined(separator: ", ")
-        if !preview.isEmpty {
-            summary += " (\(preview))"
-        }
-
-        return UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 0,
-                windowMinutes: nil,
-                resetsAt: nil,
-                resetDescription: summary),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: nil)
-    }
-}
-
-enum GroqAPIError: LocalizedError {
-    case invalidResponse
-    case httpError(statusCode: Int)
-    case decodingError
-
-    var errorDescription: String? {
-        switch self {
-        case .invalidResponse:
-            "Invalid response from Groq API"
-        case let .httpError(statusCode):
-            "Groq API returned status code \(statusCode)"
-        case .decodingError:
-            "Failed to decode Groq API response"
-        }
-    }
-}

package/Sources/RunicCore/Providers/Kimi/KimiProviderDescriptor.swift

@@ -1,83 +0,0 @@
-import Foundation
-import RunicMacroSupport
-
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
-public enum KimiProviderDescriptor {
-    static func makeDescriptor() -> ProviderDescriptor {
-        ProviderDescriptor(
-            id: .kimi,
-            metadata: ProviderMetadata(
-                id: .kimi,
-                displayName: "Kimi",
-                sessionLabel: "Models",
-                weeklyLabel: "",
-                opusLabel: nil,
-                supportsOpus: false,
-                supportsCredits: false,
-                creditsHint: "Shows model availability from Kimi API.",
-                toggleTitle: "Show Kimi usage",
-                cliName: "kimi",
-                defaultEnabled: false,
-                isPrimaryProvider: false,
-                usesAccountFallback: false,
-                dashboardURL: "https://platform.moonshot.ai/console",
-                statusPageURL: nil,
-                usageCoverage: ProviderUsageCoverage(
-                    supportsModelBreakdown: true,
-                    supportsTokenMetrics: false,
-                    supportsProjectAttribution: false)),
-            branding: ProviderBranding(
-                iconStyle: .kimi,
-                iconResourceName: "ProviderIcon-kimi",
-                color: ProviderColor(red: 0 / 255, green: 129 / 255, blue: 255 / 255)),
-            tokenCost: ProviderTokenCostConfig(
-                supportsTokenCost: false,
-                noDataMessage: { "Kimi cost summary is not supported." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .cli],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [KimiAPIFetchStrategy()] })),
-            cli: ProviderCLIConfig(
-                name: "kimi",
-                aliases: ["moonshot"],
-                versionDetector: nil))
-    }
-}
-
-struct KimiAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "kimi.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveTokenResolution(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let tokenRes = Self.resolveTokenResolution(environment: context.env) else {
-            throw KimiSettingsError.missingToken
-        }
-        let usage = try await KimiUsageFetcher.fetchModels(apiKey: tokenRes.token)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: tokenRes.source.rawValue)
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveTokenResolution(environment: [String: String]) -> ProviderTokenResolution? {
-        ProviderTokenResolver.kimiResolution(environment: environment)
-    }
-}
-
-enum KimiSettingsError: LocalizedError {
-    case missingToken
-
-    var errorDescription: String? {
-        switch self {
-        case .missingToken:
-            "Kimi API key not found. Set it in Preferences → Providers → Kimi or export KIMI_API_KEY."
-        }
-    }
-}

package/Sources/RunicCore/Providers/Kimi/KimiUsageFetcher.swift

@@ -1,77 +0,0 @@
-import Foundation
-
-struct KimiModelsResponse: Decodable {
-    let data: [Model]?
-
-    struct Model: Decodable {
-        let id: String?
-    }
-}
-
-enum KimiUsageFetcher {
-    static let apiURL = URL(string: "https://api.moonshot.ai/v1/models")!
-    private static let requestTimeout: TimeInterval = 20
-
-    static func fetchModels(apiKey: String) async throws -> KimiModelsResponse {
-        var request = URLRequest(url: apiURL)
-        request.timeoutInterval = Self.requestTimeout
-        request.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
-        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw KimiAPIError.invalidResponse
-        }
-
-        guard httpResponse.statusCode == 200 else {
-            let body = String(data: data, encoding: .utf8)?
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-            throw KimiAPIError.httpError(
-                statusCode: httpResponse.statusCode,
-                body: body?.isEmpty == false ? body : nil)
-        }
-
-        let decoder = JSONDecoder()
-        return try decoder.decode(KimiModelsResponse.self, from: data)
-    }
-}
-
-extension KimiModelsResponse {
-    func toUsageSnapshot() -> UsageSnapshot {
-        let models = (self.data ?? []).compactMap(\.id)
-        var summary = "Models available: \(models.count)"
-        let preview = models.prefix(3).joined(separator: ", ")
-        if !preview.isEmpty {
-            summary += " (\(preview))"
-        }
-
-        return UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 0,
-                windowMinutes: nil,
-                resetsAt: nil,
-                resetDescription: summary),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: nil)
-    }
-}
-
-enum KimiAPIError: LocalizedError {
-    case invalidResponse
-    case httpError(statusCode: Int, body: String?)
-
-    var errorDescription: String? {
-        switch self {
-        case .invalidResponse:
-            return "Invalid response from Kimi API"
-        case let .httpError(statusCode, body):
-            if let body, !body.isEmpty {
-                return "Kimi API returned status code \(statusCode): \(body)"
-            }
-            return "Kimi API returned status code \(statusCode)"
-        }
-    }
-}

package/Sources/RunicCore/Providers/MiniMax/MiniMaxProviderDescriptor.swift

@@ -1,97 +0,0 @@
-import Foundation
-import RunicMacroSupport
-
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
-public enum MiniMaxProviderDescriptor {
-    static func makeDescriptor() -> ProviderDescriptor {
-        ProviderDescriptor(
-            id: .minimax,
-            metadata: ProviderMetadata(
-                id: .minimax,
-                displayName: "MiniMax",
-                sessionLabel: "Plan",
-                weeklyLabel: "Cycle",
-                opusLabel: nil,
-                supportsOpus: false,
-                supportsCredits: false,
-                creditsHint: "",
-                toggleTitle: "Show MiniMax usage",
-                cliName: "minimax",
-                defaultEnabled: false,
-                isPrimaryProvider: false,
-                usesAccountFallback: false,
-                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
-                dashboardURL: "https://platform.minimax.io/user-center/payment/coding-plan",
-                statusPageURL: nil,
-                usageCoverage: ProviderUsageCoverage(
-                    supportsModelBreakdown: false,
-                    supportsTokenMetrics: true,
-                    supportsProjectAttribution: false)),
-            branding: ProviderBranding(
-                iconStyle: .minimax,
-                iconResourceName: "ProviderIcon-minimax",
-                color: ProviderColor(red: 50 / 255, green: 50 / 255, blue: 70 / 255)),
-            tokenCost: ProviderTokenCostConfig(
-                supportsTokenCost: false,
-                noDataMessage: { "MiniMax cost summary is not supported." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .api, .web],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [
-                    MiniMaxAPIFetchStrategy(),
-                    MiniMaxWebFetchStrategy(),
-                ] })),
-            cli: ProviderCLIConfig(
-                name: "minimax",
-                aliases: ["minimax-api"],
-                versionDetector: nil))
-    }
-}
-
-struct MiniMaxWebFetchStrategy: ProviderFetchStrategy {
-    let id: String = "minimax.web"
-    let kind: ProviderFetchKind = .web
-
-    func isAvailable(_: ProviderFetchContext) async -> Bool {
-        true
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        let fetcher = MiniMaxWebUsageFetcher()
-        let result = try await fetcher.fetchUsage(
-            timeout: context.webTimeout,
-            logger: context.verbose ? { RunicLog.logger("minimax-web").debug("\($0)") } : nil)
-        return self.makeResult(
-            usage: result.usage,
-            sourceLabel: result.sourceLabel)
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-}
-
-struct MiniMaxAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "minimax.api"
-    let kind: ProviderFetchKind = .api
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        ProviderTokenResolver.minimaxApiKeyResolution(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let tokenRes = ProviderTokenResolver.minimaxApiKeyResolution(environment: context.env) else {
-            throw ProviderFetchError.missingCredentials
-        }
-
-        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(apiKey: tokenRes.token)
-
-        return self.makeResult(
-            usage: snapshot.toUsageSnapshot(),
-            sourceLabel: "API")
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        true
-    }
-}

package/Sources/RunicCore/Providers/MiniMax/MiniMaxSettingsReader.swift

@@ -1,54 +0,0 @@
-import Foundation
-
-public struct MiniMaxSettingsReader: Sendable {
-    private static let log = RunicLog.logger("minimax-settings")
-
-    public static let cookieKey = "MINIMAX_COOKIE"
-    public static let cookieHeaderKey = "MINIMAX_COOKIE_HEADER"
-    public static let groupIDKey = "MINIMAX_GROUP_ID"
-
-    public static func cookieHeader(
-        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
-    {
-        if let header = self.cleaned(environment[cookieHeaderKey]) { return header }
-        if let header = self.cleaned(environment[cookieKey]) { return header }
-        return nil
-    }
-
-    public static func groupID(
-        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
-    {
-        if let groupID = self.cleaned(environment[groupIDKey]) { return groupID }
-        return nil
-    }
-
-    static func cleaned(_ raw: String?) -> String? {
-        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
-            return nil
-        }
-
-        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
-            (value.hasPrefix("'") && value.hasSuffix("'"))
-        {
-            value.removeFirst()
-            value.removeLast()
-        }
-
-        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
-        return value.isEmpty ? nil : value
-    }
-}
-
-public enum MiniMaxSettingsError: LocalizedError, Sendable {
-    case missingCookieHeader
-    case missingGroupID
-
-    public var errorDescription: String? {
-        switch self {
-        case .missingCookieHeader:
-            "MiniMax session cookie not found. Set it in Settings → Providers → MiniMax or via MINIMAX_COOKIE."
-        case .missingGroupID:
-            "MiniMax Group ID not found. Set it in Settings → Providers → MiniMax or via MINIMAX_GROUP_ID."
-        }
-    }
-}

package/Sources/RunicCore/Providers/MiniMax/MiniMaxUsageFetcher.swift

@@ -1,168 +0,0 @@
-import Foundation
-#if canImport(FoundationNetworking)
-import FoundationNetworking
-#endif
-
-/// MiniMax quota/usage response structure (New API)
-public struct MiniMaxQuotaResponse: Decodable {
-    public let baseResponse: MiniMaxBaseResponse
-    public let modelRemains: [MiniMaxModelRemain]?
-
-    enum CodingKeys: String, CodingKey {
-        case baseResponse = "base_resp"
-        case modelRemains = "model_remains"
-    }
-}
-
-public struct MiniMaxModelRemain: Decodable {
-    public let modelName: String
-    public let currentIntervalTotalCount: Int
-    public let currentIntervalUsageCount: Int
-
-    enum CodingKeys: String, CodingKey {
-        case modelName = "model_name"
-        case currentIntervalTotalCount = "current_interval_total_count"
-        case currentIntervalUsageCount = "current_interval_usage_count"
-    }
-}
-
-public struct MiniMaxBaseResponse: Decodable {
-    public let statusCode: Int
-    public let statusMsg: String
-
-    enum CodingKeys: String, CodingKey {
-        case statusCode = "status_code"
-        case statusMsg = "status_msg"
-    }
-}
-
-public struct MiniMaxUsageSnapshot: Sendable {
-    public let total: Int
-    public let used: Int
-    public let modelName: String?
-    public let updatedAt: Date
-
-    public init(total: Int, used: Int, modelName: String? = nil, updatedAt: Date) {
-        self.total = total
-        self.used = used
-        self.modelName = modelName
-        self.updatedAt = updatedAt
-    }
-
-    public var isValid: Bool {
-        self.total > 0
-    }
-}
-
-extension MiniMaxUsageSnapshot {
-    public func toUsageSnapshot() -> UsageSnapshot {
-        // "current_interval_usage_count" in the "remains" API is ambiguous.
-        // It likely represents "remaining_count" OR "used_count".
-        // Given total=4500, used=4500 (in the sample), consistent with "remains" response.
-        // But let's assume standard "usage" field naming means USED.
-        // If the user reports it shows 100% when new, we invert it.
-        // For now, let's map it as Used/Total.
-
-        let percent = self.total > 0 ? (Double(self.used) / Double(self.total)) * 100.0 : 0.0
-
-        let primary = RateWindow(
-            usedPercent: percent,
-            windowMinutes: 24 * 60,
-            resetsAt: nil,
-            resetDescription: "\(self.used) / \(self.total) (Please verify meaning)",
-            label: self.modelName?.trimmingCharacters(in: .whitespacesAndNewlines))
-
-        let identity = ProviderIdentitySnapshot(
-            providerID: .minimax,
-            accountEmail: nil,
-            accountOrganization: nil,
-            loginMethod: "api-key")
-
-        return UsageSnapshot(
-            primary: primary,
-            secondary: nil,
-            tertiary: nil,
-            providerCost: nil,
-            updatedAt: self.updatedAt,
-            identity: identity)
-    }
-}
-
-/// Fetches usage stats from the MiniMax API
-public struct MiniMaxUsageFetcher: Sendable {
-    private static let log = RunicLog.logger("minimax-usage")
-
-    /// Corrected endpoint based on documentation
-    private static let quotaAPIURL = "https://platform.minimax.io/v1/api/openplatform/coding_plan/remains"
-
-    /// Fetches usage stats from MiniMax using the provided API key
-    /// GroupID is no longer required for this endpoint based on user input
-    public static func fetchUsage(apiKey: String) async throws -> MiniMaxUsageSnapshot {
-        guard !apiKey.isEmpty else {
-            throw MiniMaxUsageError.invalidCredentials
-        }
-
-        var request = URLRequest(url: URL(string: quotaAPIURL)!)
-        request.httpMethod = "GET"
-        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
-        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw MiniMaxUsageError.networkError("Invalid response")
-        }
-
-        guard httpResponse.statusCode == 200 else {
-            let errorMessage = String(data: data, encoding: .utf8) ?? "Unknown error"
-            Self.log.error("MiniMax API returned \(httpResponse.statusCode): \(errorMessage)")
-            throw MiniMaxUsageError.apiError("HTTP \(httpResponse.statusCode): \(errorMessage)")
-        }
-
-        Self.log.debug("MiniMax API response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
-
-        let decoder = JSONDecoder()
-        do {
-            let apiResponse = try decoder.decode(MiniMaxQuotaResponse.self, from: data)
-
-            if apiResponse.baseResponse.statusCode != 0 {
-                throw MiniMaxUsageError.apiError(apiResponse.baseResponse.statusMsg)
-            }
-
-            guard let firstModel = apiResponse.modelRemains?.first else {
-                throw MiniMaxUsageError.parseFailed("No model quota found")
-            }
-
-            return MiniMaxUsageSnapshot(
-                total: firstModel.currentIntervalTotalCount,
-                used: firstModel.currentIntervalUsageCount,
-                modelName: firstModel.modelName,
-                updatedAt: Date())
-
-        } catch {
-            Self.log.error("MiniMax parsing error: \(error.localizedDescription)")
-            throw MiniMaxUsageError.parseFailed(error.localizedDescription)
-        }
-    }
-}
-
-/// Errors that can occur during MiniMax usage fetching
-public enum MiniMaxUsageError: LocalizedError, Sendable {
-    case invalidCredentials
-    case networkError(String)
-    case apiError(String)
-    case parseFailed(String)
-
-    public var errorDescription: String? {
-        switch self {
-        case .invalidCredentials:
-            "Invalid MiniMax API credentials"
-        case let .networkError(message):
-            "MiniMax network error: \(message)"
-        case let .apiError(message):
-            "MiniMax API error: \(message)"
-        case let .parseFailed(message):
-            "Failed to parse MiniMax response: \(message)"
-        }
-    }
-}