@sriinnu/runic 2.0.0 → 2.11.2

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

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

@@ -1,142 +0,0 @@
-import Foundation
-
-struct AuggieUsageMetrics {
-    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 ?? self.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 {
-    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

@@ -1,141 +0,0 @@
-import Foundation
-import RunicMacroSupport
-
-@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 = 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 = 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 = 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 = 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 {
-    case missingEndpoint
-    case missingToken
-
-    var errorDescription: String? {
-        switch self {
-        case .missingEndpoint:
-            "Azure OpenAI endpoint not found. Set it in Preferences → Providers → Azure OpenAI or " +
-                "export AZURE_OPENAI_ENDPOINT."
-        case .missingToken:
-            "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

@@ -1,188 +0,0 @@
-import Foundation
-
-struct AzureOpenAIDeploymentsResponse: Decodable {
-    struct Deployment: Decodable {
-        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)"
-        }
-        // Enforce HTTPS — reject http:// to prevent cleartext token leakage.
-        guard normalized.lowercased().hasPrefix("https://") else { return nil }
-        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 {
-    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

@@ -1,126 +0,0 @@
-import Foundation
-import RunicMacroSupport
-
-@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 = 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 = 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 = 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 {
-    case missingRegion
-
-    var errorDescription: String? {
-        switch self {
-        case .missingRegion:
-            "AWS region not found. Set it in Preferences → Providers → Amazon Bedrock or " +
-                "export AWS_REGION."
-        }
-    }
-}