@sriinnu/runic 1.0.0

package/Sources/RunicCore/Providers/Auggie/AuggieProviderDescriptor.swift

@@ -0,0 +1,83 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum AuggieProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .auggie,
+            metadata: ProviderMetadata(
+                id: .auggie,
+                displayName: "Auggie",
+                sessionLabel: "Daily usage",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Shows analytics usage from Auggie API.",
+                toggleTitle: "Show Auggie usage",
+                cliName: "auggie",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://dashboard.augmentcode.com",
+                statusPageURL: nil,
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: false,
+                    supportsTokenMetrics: true,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .auggie,
+                iconResourceName: "ProviderIcon-auggie",
+                color: ProviderColor(red: 255 / 255, green: 180 / 255, blue: 0 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Auggie cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [AuggieAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "auggie",
+                aliases: ["augment"],
+                versionDetector: nil))
+    }
+}
+
+struct AuggieAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "auggie.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 AuggieSettingsError.missingToken
+        }
+        let usage = try await AuggieUsageFetcher.fetchDailyUsage(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.auggieResolution(environment: environment)
+    }
+}
+
+enum AuggieSettingsError: LocalizedError, Sendable {
+    case missingToken
+
+    var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "Auggie API token not found. Set it in Preferences → Providers → Auggie or export AUGMENT_API_TOKEN."
+        }
+    }
+}

package/Sources/RunicCore/Providers/Auggie/AuggieUsageFetcher.swift

@@ -0,0 +1,142 @@
+import Foundation
+
+struct AuggieUsageMetrics: Sendable {
+    let requestCount: Int?
+    let totalTokens: Int?
+    let inputTokens: Int?
+    let outputTokens: Int?
+
+    func toUsageSnapshot() -> UsageSnapshot {
+        var parts: [String] = []
+        if let requestCount, requestCount > 0 {
+            parts.append("Requests: \(requestCount)")
+        }
+        if let totalTokens, totalTokens > 0 {
+            parts.append("Tokens: \(totalTokens)")
+        } else {
+            if let inputTokens, inputTokens > 0 {
+                parts.append("Input: \(inputTokens)")
+            }
+            if let outputTokens, outputTokens > 0 {
+                parts.append("Output: \(outputTokens)")
+            }
+        }
+
+        let summary = parts.isEmpty ? "Usage fetched from analytics API." : parts.joined(separator: " · ")
+        return UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: summary),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: nil)
+    }
+}
+
+struct AuggieUsageFetcher {
+    static let baseURL = URL(string: "https://api.augmentcode.com/analytics/v0/daily-usage")!
+    private static let requestTimeout: TimeInterval = 20
+
+    static func fetchDailyUsage(apiKey: String) async throws -> AuggieUsageMetrics {
+        var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false)
+        components?.queryItems = [
+            URLQueryItem(name: "window", value: "day"),
+            URLQueryItem(name: "days", value: "1"),
+        ]
+        let url = components?.url ?? baseURL
+
+        var request = URLRequest(url: url)
+        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 AuggieAPIError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            throw AuggieAPIError.httpError(
+                statusCode: httpResponse.statusCode,
+                body: body?.isEmpty == false ? body : nil)
+        }
+
+        guard let root = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw AuggieAPIError.decodingError
+        }
+
+        let requestCount = Int(self.sumMetric(in: root, keys: ["requests", "request_count", "total_requests"]))
+        let inputTokens = Int(self.sumMetric(in: root, keys: ["input_tokens", "prompt_tokens"]))
+        let outputTokens = Int(self.sumMetric(in: root, keys: ["output_tokens", "completion_tokens"]))
+        let totalTokensValue = self.sumMetric(in: root, keys: ["total_tokens"])
+        let totalTokens = totalTokensValue > 0 ? Int(totalTokensValue) : {
+            let fallback = inputTokens + outputTokens
+            return fallback > 0 ? fallback : 0
+        }()
+
+        return AuggieUsageMetrics(
+            requestCount: requestCount > 0 ? requestCount : nil,
+            totalTokens: totalTokens > 0 ? totalTokens : nil,
+            inputTokens: inputTokens > 0 ? inputTokens : nil,
+            outputTokens: outputTokens > 0 ? outputTokens : nil)
+    }
+
+    private static func sumMetric(in value: Any, keys: Set<String>) -> Double {
+        var total: Double = 0
+
+        if let dict = value as? [String: Any] {
+            for (key, child) in dict {
+                let normalizedKey = key.lowercased()
+                if keys.contains(normalizedKey), let metric = self.number(from: child) {
+                    total += metric
+                }
+                total += self.sumMetric(in: child, keys: keys)
+            }
+            return total
+        }
+
+        if let list = value as? [Any] {
+            for child in list {
+                total += self.sumMetric(in: child, keys: keys)
+            }
+        }
+
+        return total
+    }
+
+    private static func number(from value: Any) -> Double? {
+        if let value = value as? NSNumber {
+            return value.doubleValue
+        }
+        if let value = value as? String {
+            return Double(value.trimmingCharacters(in: .whitespacesAndNewlines))
+        }
+        return nil
+    }
+}
+
+enum AuggieAPIError: LocalizedError, Sendable {
+    case invalidResponse
+    case decodingError
+    case httpError(statusCode: Int, body: String?)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            return "Invalid response from Auggie API"
+        case .decodingError:
+            return "Failed to decode Auggie API response"
+        case let .httpError(statusCode, body):
+            if let body, !body.isEmpty {
+                return "Auggie API returned status code \(statusCode): \(body)"
+            }
+            return "Auggie API returned status code \(statusCode)"
+        }
+    }
+}

package/Sources/RunicCore/Providers/Azure/AzureProviderDescriptor.swift

@@ -0,0 +1,141 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum AzureProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .azure,
+            metadata: ProviderMetadata(
+                id: .azure,
+                displayName: "Azure OpenAI",
+                sessionLabel: "Deployments",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Shows deployment inventory from Azure OpenAI.",
+                toggleTitle: "Show Azure OpenAI usage",
+                cliName: "azure",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://oai.azure.com/",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.azure.com/",
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: true,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .azure,
+                iconResourceName: "ProviderIcon-azure",
+                color: ProviderColor(red: 0 / 255, green: 120 / 255, blue: 212 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Azure OpenAI cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [AzureOpenAIAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "azure",
+                aliases: ["azure-openai", "aoai"],
+                versionDetector: nil))
+    }
+}
+
+struct AzureOpenAIAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "azure.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let tokenResolution = Self.resolveToken(context: context) else {
+            throw AzureSettingsError.missingToken
+        }
+        guard let endpoint = Self.resolveEndpoint(context: context) else {
+            throw AzureSettingsError.missingEndpoint
+        }
+
+        let apiVersion = Self.resolveAPIVersion(context: context)
+        let deployment = Self.resolveDeployment(context: context)
+        let usage = try await AzureUsageFetcher.fetchDeployments(
+            endpoint: endpoint,
+            apiKey: tokenResolution.token,
+            apiVersion: apiVersion)
+
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(highlightedDeployment: deployment),
+            sourceLabel: tokenResolution.source.rawValue)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveToken(context: ProviderFetchContext) -> ProviderTokenResolution? {
+        if let token = Self.cleaned(context.settings?.azure?.apiToken) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        return ProviderTokenResolver.azureOpenAIResolution(environment: context.env)
+    }
+
+    private static func resolveEndpoint(context: ProviderFetchContext) -> String? {
+        if let endpoint = Self.cleaned(context.settings?.azure?.endpoint) {
+            return endpoint
+        }
+        if let endpoint = Self.cleaned(context.env["AZURE_OPENAI_ENDPOINT"]) {
+            return endpoint
+        }
+        if let endpoint = Self.cleaned(context.env["AZURE_OPENAI_BASE_URL"]) {
+            return endpoint
+        }
+        return nil
+    }
+
+    private static func resolveAPIVersion(context: ProviderFetchContext) -> String {
+        if let version = Self.cleaned(context.settings?.azure?.apiVersion) {
+            return version
+        }
+        if let version = Self.cleaned(context.env["AZURE_OPENAI_API_VERSION"]) {
+            return version
+        }
+        return AzureUsageFetcher.defaultAPIVersion
+    }
+
+    private static func resolveDeployment(context: ProviderFetchContext) -> String? {
+        if let deployment = Self.cleaned(context.settings?.azure?.deployment) {
+            return deployment
+        }
+        if let deployment = Self.cleaned(context.env["AZURE_OPENAI_DEPLOYMENT"]) {
+            return deployment
+        }
+        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 AzureSettingsError: LocalizedError, Sendable {
+    case missingEndpoint
+    case missingToken
+
+    var errorDescription: String? {
+        switch self {
+        case .missingEndpoint:
+            return "Azure OpenAI endpoint not found. Set it in Preferences → Providers → Azure OpenAI or " +
+                "export AZURE_OPENAI_ENDPOINT."
+        case .missingToken:
+            return "Azure OpenAI API key not found. Set it in Preferences → Providers → Azure OpenAI or " +
+                "export AZURE_OPENAI_API_KEY."
+        }
+    }
+}

package/Sources/RunicCore/Providers/Azure/AzureUsageFetcher.swift

@@ -0,0 +1,186 @@
+import Foundation
+
+struct AzureOpenAIDeploymentsResponse: Decodable {
+    struct Deployment: Decodable, Sendable {
+        let id: String?
+        let model: String?
+        let status: String?
+
+        enum CodingKeys: String, CodingKey {
+            case id
+            case name
+            case model
+            case modelName
+            case status
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            if let id = try container.decodeIfPresent(String.self, forKey: .id) {
+                self.id = id
+            } else {
+                self.id = try container.decodeIfPresent(String.self, forKey: .name)
+            }
+            if let model = try container.decodeIfPresent(String.self, forKey: .model) {
+                self.model = model
+            } else {
+                self.model = try container.decodeIfPresent(String.self, forKey: .modelName)
+            }
+            self.status = try container.decodeIfPresent(String.self, forKey: .status)
+        }
+    }
+
+    let deployments: [Deployment]
+
+    enum CodingKeys: String, CodingKey {
+        case data
+        case value
+    }
+
+    init(deployments: [Deployment]) {
+        self.deployments = deployments
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        if let deployments = try container.decodeIfPresent([Deployment].self, forKey: .data) {
+            self.deployments = deployments
+            return
+        }
+        if let deployments = try container.decodeIfPresent([Deployment].self, forKey: .value) {
+            self.deployments = deployments
+            return
+        }
+        self.deployments = []
+    }
+}
+
+struct AzureUsageFetcher {
+    static let defaultAPIVersion = "2024-10-21"
+
+    static func fetchDeployments(
+        endpoint: String,
+        apiKey: String,
+        apiVersion: String) async throws -> AzureOpenAIDeploymentsResponse
+    {
+        guard let url = self.deploymentsURL(endpoint: endpoint, apiVersion: apiVersion) else {
+            throw AzureAPIError.invalidEndpoint(endpoint)
+        }
+
+        var request = URLRequest(url: url)
+        request.addValue(apiKey, forHTTPHeaderField: "api-key")
+        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 AzureAPIError.invalidResponse
+        }
+
+        guard (200 ..< 300).contains(httpResponse.statusCode) else {
+            let body = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            throw AzureAPIError.httpError(
+                statusCode: httpResponse.statusCode,
+                body: body?.isEmpty == false ? body : nil)
+        }
+
+        let decoder = JSONDecoder()
+        return try decoder.decode(AzureOpenAIDeploymentsResponse.self, from: data)
+    }
+
+    private static func deploymentsURL(endpoint: String, apiVersion: String) -> URL? {
+        guard var normalized = self.cleaned(endpoint), !normalized.isEmpty else { return nil }
+        if !normalized.contains("://") {
+            normalized = "https://\(normalized)"
+        }
+        guard let baseURL = URL(string: normalized),
+              var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false)
+        else {
+            return nil
+        }
+
+        let trimmedPath = components.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        if trimmedPath.isEmpty {
+            components.path = "/openai/deployments"
+        } else {
+            components.path = "/\(trimmedPath)/openai/deployments"
+        }
+
+        var items = components.queryItems ?? []
+        items.removeAll { $0.name.caseInsensitiveCompare("api-version") == .orderedSame }
+        items.append(URLQueryItem(name: "api-version", value: apiVersion))
+        components.queryItems = items
+        return components.url
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let trimmed, !trimmed.isEmpty else { return nil }
+        return trimmed
+    }
+}
+
+extension AzureOpenAIDeploymentsResponse {
+    func toUsageSnapshot(highlightedDeployment: String?) -> UsageSnapshot {
+        let deploymentCount = self.deployments.count
+        let uniqueModels = Self.uniqueOrdered(self.deployments.compactMap(\.model))
+        let modelPreview = uniqueModels.prefix(3).joined(separator: ", ")
+
+        var summaryParts = ["Deployments: \(deploymentCount)"]
+        if !modelPreview.isEmpty {
+            summaryParts.append("models \(modelPreview)")
+        }
+        if let highlightedDeployment,
+           !highlightedDeployment.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            summaryParts.append("target \(highlightedDeployment)")
+        }
+        let summary = summaryParts.joined(separator: " • ")
+
+        return UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: summary,
+                label: "Deployments"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: nil)
+    }
+
+    private static func uniqueOrdered(_ values: [String]) -> [String] {
+        var seen: Set<String> = []
+        var ordered: [String] = []
+        for value in values {
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty else { continue }
+            guard !seen.contains(trimmed) else { continue }
+            seen.insert(trimmed)
+            ordered.append(trimmed)
+        }
+        return ordered
+    }
+}
+
+enum AzureAPIError: LocalizedError, Sendable {
+    case invalidEndpoint(String)
+    case invalidResponse
+    case httpError(statusCode: Int, body: String?)
+
+    var errorDescription: String? {
+        switch self {
+        case let .invalidEndpoint(endpoint):
+            return "Invalid Azure OpenAI endpoint: \(endpoint)"
+        case .invalidResponse:
+            return "Invalid response from Azure OpenAI API"
+        case let .httpError(statusCode, body):
+            if let body, !body.isEmpty {
+                return "Azure OpenAI API returned status code \(statusCode): \(body)"
+            }
+            return "Azure OpenAI API returned status code \(statusCode)"
+        }
+    }
+}

package/Sources/RunicCore/Providers/Bedrock/BedrockProviderDescriptor.swift

@@ -0,0 +1,126 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum BedrockProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .bedrock,
+            metadata: ProviderMetadata(
+                id: .bedrock,
+                displayName: "Amazon Bedrock",
+                sessionLabel: "Models",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Shows foundation model inventory via AWS CLI.",
+                toggleTitle: "Show Amazon Bedrock usage",
+                cliName: "bedrock",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://console.aws.amazon.com/bedrock/",
+                statusPageURL: nil,
+                statusLinkURL: "https://health.aws.amazon.com/health/status",
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: true,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .bedrock,
+                iconResourceName: "ProviderIcon-bedrock",
+                color: ProviderColor(red: 255 / 255, green: 153 / 255, blue: 0 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Amazon Bedrock cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [BedrockCLIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "bedrock",
+                aliases: ["aws-bedrock", "amazon-bedrock"],
+                versionDetector: nil))
+    }
+}
+
+struct BedrockCLIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "bedrock.cli"
+    let kind: ProviderFetchKind = .cli
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let region = Self.resolveRegion(context: context) else {
+            throw BedrockSettingsError.missingRegion
+        }
+        let profile = Self.resolveProfile(context: context)
+        let modelFilter = Self.resolveModelFilter(context: context)
+        let usage = try await BedrockUsageFetcher.fetchModels(
+            region: region,
+            profile: profile,
+            modelFilter: modelFilter)
+
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(region: region, profile: profile, modelFilter: modelFilter),
+            sourceLabel: profile.map { "aws-cli:\($0)" } ?? "aws-cli")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveRegion(context: ProviderFetchContext) -> String? {
+        if let region = Self.cleaned(context.settings?.bedrock?.region) {
+            return region
+        }
+        if let region = Self.cleaned(context.env["AWS_REGION"]) {
+            return region
+        }
+        if let region = Self.cleaned(context.env["AWS_DEFAULT_REGION"]) {
+            return region
+        }
+        return nil
+    }
+
+    private static func resolveProfile(context: ProviderFetchContext) -> String? {
+        if let profile = Self.cleaned(context.settings?.bedrock?.profile) {
+            return profile
+        }
+        if let profile = Self.cleaned(context.env["AWS_PROFILE"]) {
+            return profile
+        }
+        return nil
+    }
+
+    private static func resolveModelFilter(context: ProviderFetchContext) -> String? {
+        if let model = Self.cleaned(context.settings?.bedrock?.modelID) {
+            return model
+        }
+        if let model = Self.cleaned(context.env["BEDROCK_MODEL_ID"]) {
+            return model
+        }
+        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 BedrockSettingsError: LocalizedError, Sendable {
+    case missingRegion
+
+    var errorDescription: String? {
+        switch self {
+        case .missingRegion:
+            return "AWS region not found. Set it in Preferences → Providers → Amazon Bedrock or " +
+                "export AWS_REGION."
+        }
+    }
+}