@sriinnu/runic 1.0.0

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

@@ -0,0 +1,83 @@
+import RunicMacroSupport
+import Foundation
+
+@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, Sendable {
+    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

@@ -0,0 +1,71 @@
+import Foundation
+
+struct GroqModelsResponse: Decodable {
+    let data: [Model]?
+
+    struct Model: Decodable {
+        let id: String?
+    }
+}
+
+struct 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, Sendable {
+    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

@@ -0,0 +1,83 @@
+import RunicMacroSupport
+import Foundation
+
+@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, Sendable {
+    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

@@ -0,0 +1,77 @@
+import Foundation
+
+struct KimiModelsResponse: Decodable {
+    let data: [Model]?
+
+    struct Model: Decodable {
+        let id: String?
+    }
+}
+
+struct 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, Sendable {
+    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

@@ -0,0 +1,92 @@
+import RunicMacroSupport
+import Foundation
+
+@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

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

@@ -0,0 +1,171 @@
+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)")
+        }
+
+        // Log raw response for debugging
+        if let jsonString = String(data: data, encoding: .utf8) {
+            Self.log.debug("MiniMax API response: \(jsonString)")
+        }
+
+        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)"
+        }
+    }
+}