@sriinnu/runic 1.0.0

package/Sources/RunicCore/Providers/SambaNova/SambaNovaUsageFetcher.swift

@@ -0,0 +1,75 @@
+import Foundation
+
+struct SambaNovaModelsResponse: Decodable {
+    let data: [Model]?
+
+    struct Model: Decodable {
+        let id: String?
+    }
+}
+
+struct SambaNovaUsageFetcher {
+    static let apiURL = URL(string: "https://api.sambanova.ai/v1/models")!
+
+    static func fetchModels(apiKey: String) async throws -> SambaNovaModelsResponse {
+        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 SambaNovaAPIError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            throw SambaNovaAPIError.httpError(
+                statusCode: httpResponse.statusCode,
+                body: body?.isEmpty == false ? body : nil)
+        }
+
+        let decoder = JSONDecoder()
+        return try decoder.decode(SambaNovaModelsResponse.self, from: data)
+    }
+}
+
+extension SambaNovaModelsResponse {
+    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 SambaNovaAPIError: LocalizedError, Sendable {
+    case invalidResponse
+    case httpError(statusCode: Int, body: String?)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            return "Invalid response from SambaNova API"
+        case let .httpError(statusCode, body):
+            if let body, !body.isEmpty {
+                return "SambaNova API returned status code \(statusCode): \(body)"
+            }
+            return "SambaNova API returned status code \(statusCode)"
+        }
+    }
+}

package/Sources/RunicCore/Providers/Together/TogetherProviderDescriptor.swift

@@ -0,0 +1,83 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum TogetherProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .together,
+            metadata: ProviderMetadata(
+                id: .together,
+                displayName: "Together",
+                sessionLabel: "Models",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Shows model availability from Together API.",
+                toggleTitle: "Show Together usage",
+                cliName: "together",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://api.together.xyz/settings/api-keys",
+                statusPageURL: nil,
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: true,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .together,
+                iconResourceName: "ProviderIcon-together",
+                color: ProviderColor(red: 98 / 255, green: 76 / 255, blue: 245 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Together cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [TogetherAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "together",
+                aliases: [],
+                versionDetector: nil))
+    }
+}
+
+struct TogetherAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "together.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 TogetherSettingsError.missingToken
+        }
+        let usage = try await TogetherUsageFetcher.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.togetherResolution(environment: environment)
+    }
+}
+
+enum TogetherSettingsError: LocalizedError, Sendable {
+    case missingToken
+
+    var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "Together API key not found. Set it in Preferences → Providers → Together or export TOGETHER_API_KEY."
+        }
+    }
+}

package/Sources/RunicCore/Providers/Together/TogetherUsageFetcher.swift

@@ -0,0 +1,75 @@
+import Foundation
+
+struct TogetherModelsResponse: Decodable {
+    let data: [Model]?
+
+    struct Model: Decodable {
+        let id: String?
+    }
+}
+
+struct TogetherUsageFetcher {
+    static let apiURL = URL(string: "https://api.together.xyz/v1/models")!
+
+    static func fetchModels(apiKey: String) async throws -> TogetherModelsResponse {
+        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 TogetherAPIError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            throw TogetherAPIError.httpError(
+                statusCode: httpResponse.statusCode,
+                body: body?.isEmpty == false ? body : nil)
+        }
+
+        let decoder = JSONDecoder()
+        return try decoder.decode(TogetherModelsResponse.self, from: data)
+    }
+}
+
+extension TogetherModelsResponse {
+    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 TogetherAPIError: LocalizedError, Sendable {
+    case invalidResponse
+    case httpError(statusCode: Int, body: String?)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            return "Invalid response from Together API"
+        case let .httpError(statusCode, body):
+            if let body, !body.isEmpty {
+                return "Together API returned status code \(statusCode): \(body)"
+            }
+            return "Together API returned status code \(statusCode)"
+        }
+    }
+}

package/Sources/RunicCore/Providers/VertexAI/VertexAIProviderDescriptor.swift

@@ -0,0 +1,123 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum VertexAIProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .vertexai,
+            metadata: ProviderMetadata(
+                id: .vertexai,
+                displayName: "Vertex AI",
+                sessionLabel: "Requests",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Shows model inventory via gcloud CLI.",
+                toggleTitle: "Show Vertex AI usage",
+                cliName: "vertexai",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://console.cloud.google.com/vertex-ai",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.cloud.google.com/",
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: true,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .vertexai,
+                iconResourceName: "ProviderIcon-vertexai",
+                color: ProviderColor(red: 66 / 255, green: 133 / 255, blue: 244 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Vertex AI cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [VertexAICLIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "vertexai",
+                aliases: ["vertex-ai", "google-vertex"],
+                versionDetector: nil))
+    }
+}
+
+struct VertexAICLIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "vertexai.cli"
+    let kind: ProviderFetchKind = .cli
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let project = Self.resolveProject(context: context)
+        let location = Self.resolveLocation(context: context)
+
+        guard let project else {
+            throw VertexAISettingsError.missingProject
+        }
+
+        let usage = try await VertexAIUsageFetcher.fetchModels(
+            project: project,
+            location: location ?? "us-central1")
+
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(project: project, location: location ?? "us-central1"),
+            sourceLabel: "gcloud")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveProject(context: ProviderFetchContext) -> String? {
+        if let project = Self.cleaned(context.settings?.vertexai?.project) {
+            return project
+        }
+        if let project = Self.cleaned(context.env["VERTEX_AI_PROJECT"]) {
+            return project
+        }
+        if let project = Self.cleaned(context.env["GOOGLE_CLOUD_PROJECT"]) {
+            return project
+        }
+        if let project = Self.cleaned(context.env["GCLOUD_PROJECT"]) {
+            return project
+        }
+        return nil
+    }
+
+    private static func resolveLocation(context: ProviderFetchContext) -> String? {
+        if let location = Self.cleaned(context.settings?.vertexai?.location) {
+            return location
+        }
+        if let location = Self.cleaned(context.env["VERTEX_AI_LOCATION"]) {
+            return location
+        }
+        if let location = Self.cleaned(context.env["GOOGLE_CLOUD_REGION"]) {
+            return location
+        }
+        return nil
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let trimmed, !trimmed.isEmpty else { return nil }
+        return trimmed
+    }
+}
+
+enum VertexAISettingsError: LocalizedError, Sendable {
+    case missingProject
+
+    var errorDescription: String? {
+        switch self {
+        case .missingProject:
+            return "Google Cloud project not found. Set it in Preferences \u{2192} Providers \u{2192} Vertex AI or " +
+                "export VERTEX_AI_PROJECT."
+        }
+    }
+}

package/Sources/RunicCore/Providers/VertexAI/VertexAISettingsReader.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+public struct VertexAISettingsReader: Sendable {
+    private static let log = RunicLog.logger("vertexai-settings")
+
+    public static let projectKey = "VERTEX_AI_PROJECT"
+    public static let locationKey = "VERTEX_AI_LOCATION"
+    public static let credentialsKey = "GOOGLE_APPLICATION_CREDENTIALS"
+
+    public static func project(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        if let value = self.cleaned(environment[projectKey]) { return value }
+        if let value = self.cleaned(environment["GOOGLE_CLOUD_PROJECT"]) { return value }
+        if let value = self.cleaned(environment["GCLOUD_PROJECT"]) { return value }
+        return nil
+    }
+
+    public static func location(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        if let value = self.cleaned(environment[locationKey]) { return value }
+        if let value = self.cleaned(environment["GOOGLE_CLOUD_REGION"]) { return value }
+        return nil
+    }
+
+    public static func credentials(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[credentialsKey])
+    }
+
+    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
+    }
+}

package/Sources/RunicCore/Providers/VertexAI/VertexAIUsageFetcher.swift

@@ -0,0 +1,144 @@
+import Foundation
+
+struct VertexAIModelsResponse: Decodable, Sendable {
+    struct Model: Decodable, Sendable {
+        let name: String?
+        let displayName: String?
+    }
+
+    let models: [Model]
+
+    init(models: [Model]) {
+        self.models = models
+    }
+
+    init(from decoder: Decoder) throws {
+        // gcloud ai models list --format=json returns a top-level array
+        let container = try decoder.singleValueContainer()
+        self.models = try container.decode([Model].self)
+    }
+}
+
+struct VertexAIUsageFetcher {
+    private static let commandTimeout: TimeInterval = 20
+
+    static func fetchModels(
+        project: String,
+        location: String) async throws -> VertexAIModelsResponse
+    {
+        let output = try await self.runGCloudCLI(
+            arguments: [
+                "ai", "models", "list",
+                "--project=\(project)",
+                "--region=\(location)",
+                "--format=json",
+            ])
+
+        let decoder = JSONDecoder()
+        let decoded: VertexAIModelsResponse
+        do {
+            decoded = try decoder.decode(VertexAIModelsResponse.self, from: output)
+        } catch {
+            throw VertexAICLIError.decodeFailed(error.localizedDescription)
+        }
+
+        return decoded
+    }
+
+    private static func runGCloudCLI(arguments: [String]) async throws -> Data {
+        var environment = ProcessInfo.processInfo.environment
+        environment["PATH"] = self.effectivePATH(existing: environment["PATH"])
+
+        do {
+            let result = try await SubprocessRunner.run(
+                binary: "/usr/bin/env",
+                arguments: ["gcloud"] + arguments,
+                environment: environment,
+                timeout: Self.commandTimeout,
+                label: "vertexai.cli")
+            let output = Data(result.stdout.utf8)
+            guard !output.isEmpty else {
+                throw VertexAICLIError.emptyResponse
+            }
+            return output
+        } catch let error as SubprocessRunnerError {
+            switch error {
+            case .binaryNotFound:
+                throw VertexAICLIError.gcloudNotFound
+            case let .launchFailed(details):
+                throw VertexAICLIError.commandFailed(statusCode: -1, detail: details)
+            case .timedOut:
+                throw VertexAICLIError.commandTimedOut
+            case let .nonZeroExit(code, stderr):
+                throw VertexAICLIError.commandFailed(statusCode: Int(code), detail: stderr)
+            }
+        }
+    }
+
+    private static func effectivePATH(existing: String?) -> String {
+        let defaults = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]
+        var parts = (existing ?? "")
+            .split(separator: ":")
+            .map(String.init)
+            .filter { !$0.isEmpty }
+        for path in defaults where !parts.contains(path) {
+            parts.append(path)
+        }
+        return parts.joined(separator: ":")
+    }
+}
+
+extension VertexAIModelsResponse {
+    func toUsageSnapshot(project: String, location: String) -> UsageSnapshot {
+        let count = self.models.count
+        let preview = self.models
+            .compactMap(\.displayName)
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+            .prefix(3)
+            .joined(separator: ", ")
+
+        var summaryParts: [String] = ["Models available: \(count)", "project \(project)", "region \(location)"]
+        if !preview.isEmpty {
+            summaryParts.append(preview)
+        }
+
+        return UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: summaryParts.joined(separator: " \u{2022} "),
+                label: "AI models"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: nil)
+    }
+}
+
+enum VertexAICLIError: LocalizedError, Sendable {
+    case gcloudNotFound
+    case commandFailed(statusCode: Int, detail: String?)
+    case commandTimedOut
+    case decodeFailed(String)
+    case emptyResponse
+
+    var errorDescription: String? {
+        switch self {
+        case .gcloudNotFound:
+            return "gcloud CLI is not available. Install the Google Cloud SDK and ensure `gcloud` is on PATH."
+        case let .commandFailed(statusCode, detail):
+            if let detail, !detail.isEmpty {
+                return "Vertex AI CLI request failed (\(statusCode)): \(detail)"
+            }
+            return "Vertex AI CLI request failed with exit code \(statusCode)."
+        case .commandTimedOut:
+            return "Vertex AI CLI request timed out."
+        case let .decodeFailed(detail):
+            return "Could not decode Vertex AI response: \(detail)"
+        case .emptyResponse:
+            return "Vertex AI returned an empty response."
+        }
+    }
+}

package/Sources/RunicCore/Providers/XAI/XAIProviderDescriptor.swift

@@ -0,0 +1,83 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum XAIProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .xai,
+            metadata: ProviderMetadata(
+                id: .xai,
+                displayName: "xAI",
+                sessionLabel: "Models",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Shows model availability from xAI API.",
+                toggleTitle: "Show xAI usage",
+                cliName: "xai",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://console.x.ai",
+                statusPageURL: nil,
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: true,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .xai,
+                iconResourceName: "ProviderIcon-xai",
+                color: ProviderColor(red: 20 / 255, green: 20 / 255, blue: 20 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "xAI cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [XAIApiFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "xai",
+                aliases: ["grok"],
+                versionDetector: nil))
+    }
+}
+
+struct XAIApiFetchStrategy: ProviderFetchStrategy {
+    let id: String = "xai.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 XAISettingsError.missingToken
+        }
+        let usage = try await XAIUsageFetcher.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.xaiResolution(environment: environment)
+    }
+}
+
+enum XAISettingsError: LocalizedError, Sendable {
+    case missingToken
+
+    var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "xAI API key not found. Set it in Preferences → Providers → xAI or export XAI_API_KEY."
+        }
+    }
+}