@sriinnu/runic 1.0.0 → 2.0.0

package/Sources/RunicCore/Performance/PerformanceModels.swift

@@ -155,8 +155,8 @@ public struct ErrorEvent: Codable, Sendable, Identifiable {
 public struct DailyPerformanceStats: Codable, Sendable, Identifiable {
     /// Computed identifier from provider-model-date
     public var id: String {
-        let modelPart = model.map { "-\($0)" } ?? ""
-        return "\(provider)\(modelPart)-\(date)"
+        let modelPart = self.model.map { "-\($0)" } ?? ""
+        return "\(self.provider)\(modelPart)-\(self.date)"
     }
 
     /// Provider for these statistics
@@ -298,7 +298,7 @@ extension QualityRating {
 
     /// Validates that the rating is within acceptable bounds (1-5)
     public var isValid: Bool {
-        rating >= 1 && rating <= 5
+        self.rating >= 1 && self.rating <= 5
     }
 }
 
@@ -327,7 +327,7 @@ extension LatencyMetric {
 
     /// Computed duration in seconds
     public var durationSeconds: Double {
-        Double(durationMs) / 1000.0
+        Double(self.durationMs) / 1000.0
     }
 }
 

package/Sources/RunicCore/Performance/PerformanceStorageImpl.swift

@@ -3,7 +3,6 @@ import SQLite3
 
 /// Storage layer for performance metrics using SQLite
 public final class PerformanceStorageImpl {
-
     // MARK: - Properties
 
     private var db: OpaquePointer?
@@ -14,8 +13,7 @@ public final class PerformanceStorageImpl {
     public init() {
         let appSupport = FileManager.default.urls(
             for: .applicationSupportDirectory,
-            in: .userDomainMask
-        ).first!
+            in: .userDomainMask).first!
         let runicDir = appSupport.appendingPathComponent("Runic")
 
         // Ensure directory exists
@@ -25,7 +23,7 @@ public final class PerformanceStorageImpl {
     }
 
     deinit {
-        if let db = db {
+        if let db {
             sqlite3_close(db)
         }
     }
@@ -33,20 +31,20 @@ public final class PerformanceStorageImpl {
     // MARK: - Database Connection
 
     private func open() throws {
-        guard db == nil else { return }
+        guard self.db == nil else { return }
 
         let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX
-        let result = sqlite3_open_v2(dbPath.path, &db, flags, nil)
+        let result = sqlite3_open_v2(dbPath.path, &self.db, flags, nil)
 
         guard result == SQLITE_OK else {
-            throw StorageError.openFailed(message: String(cString: sqlite3_errmsg(db)))
+            throw StorageError.openFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
 
-        try createTablesIfNeeded()
+        try self.createTablesIfNeeded()
     }
 
     private func close() {
-        if let db = db {
+        if let db {
             sqlite3_close(db)
             self.db = nil
         }
@@ -120,18 +118,18 @@ public final class PerformanceStorageImpl {
             "CREATE INDEX IF NOT EXISTS idx_latency_created ON latency_metrics(created_at)",
             "CREATE INDEX IF NOT EXISTS idx_quality_timestamp ON quality_ratings(timestamp)",
             "CREATE INDEX IF NOT EXISTS idx_error_timestamp ON error_events(timestamp)",
-            "CREATE INDEX IF NOT EXISTS idx_daily_stats_date ON daily_stats(date)"
+            "CREATE INDEX IF NOT EXISTS idx_daily_stats_date ON daily_stats(date)",
         ]
 
         for schema in schemas {
-            try execute(schema)
+            try self.execute(schema)
         }
     }
 
     // MARK: - Execute SQL
 
     private func execute(_ sql: String) throws {
-        guard let db = db else {
+        guard let db else {
             throw StorageError.notOpen
         }
 
@@ -148,24 +146,29 @@ public final class PerformanceStorageImpl {
     // MARK: - Save Metrics
 
     public func save(latency: LatencyMetric) async throws {
-        try open()
+        try self.open()
 
         let sql = """
-            INSERT OR REPLACE INTO latency_metrics
-            (id, request_id, provider, model, start_time, end_time, duration_ms, success, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """
+        INSERT OR REPLACE INTO latency_metrics
+        (id, request_id, provider, model, start_time, end_time, duration_ms, success, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """
 
         var statement: OpaquePointer?
         defer { sqlite3_finalize(statement) }
 
-        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
-            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        guard sqlite3_prepare_v2(self.db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
 
         sqlite3_bind_text(statement, 1, latency.id, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
         sqlite3_bind_text(statement, 2, latency.requestID, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
-        sqlite3_bind_text(statement, 3, latency.provider.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(
+            statement,
+            3,
+            latency.provider.rawValue,
+            -1,
+            unsafeBitCast(-1, to: sqlite3_destructor_type.self))
 
         if let model = latency.model {
             sqlite3_bind_text(statement, 4, model, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
@@ -180,29 +183,34 @@ public final class PerformanceStorageImpl {
         sqlite3_bind_double(statement, 9, latency.createdAt.timeIntervalSince1970)
 
         guard sqlite3_step(statement) == SQLITE_DONE else {
-            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(db)))
+            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
     }
 
     public func save(rating: QualityRating) async throws {
-        try open()
+        try self.open()
 
         let sql = """
-            INSERT OR REPLACE INTO quality_ratings
-            (id, request_id, provider, model, rating, comment, timestamp)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            """
+        INSERT OR REPLACE INTO quality_ratings
+        (id, request_id, provider, model, rating, comment, timestamp)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        """
 
         var statement: OpaquePointer?
         defer { sqlite3_finalize(statement) }
 
-        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
-            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        guard sqlite3_prepare_v2(self.db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
 
         sqlite3_bind_text(statement, 1, rating.id, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
         sqlite3_bind_text(statement, 2, rating.requestID, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
-        sqlite3_bind_text(statement, 3, rating.provider.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(
+            statement,
+            3,
+            rating.provider.rawValue,
+            -1,
+            unsafeBitCast(-1, to: sqlite3_destructor_type.self))
 
         if let model = rating.model {
             sqlite3_bind_text(statement, 4, model, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
@@ -221,29 +229,39 @@ public final class PerformanceStorageImpl {
         sqlite3_bind_double(statement, 7, rating.timestamp.timeIntervalSince1970)
 
         guard sqlite3_step(statement) == SQLITE_DONE else {
-            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(db)))
+            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
     }
 
     public func save(error: ErrorEvent) async throws {
-        try open()
+        try self.open()
 
         let sql = """
-            INSERT OR REPLACE INTO error_events
-            (id, provider, error_type, error_message, retry_count, timestamp)
-            VALUES (?, ?, ?, ?, ?, ?)
-            """
+        INSERT OR REPLACE INTO error_events
+        (id, provider, error_type, error_message, retry_count, timestamp)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """
 
         var statement: OpaquePointer?
         defer { sqlite3_finalize(statement) }
 
-        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
-            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        guard sqlite3_prepare_v2(self.db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
 
         sqlite3_bind_text(statement, 1, error.id, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
-        sqlite3_bind_text(statement, 2, error.provider.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
-        sqlite3_bind_text(statement, 3, error.errorType.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(
+            statement,
+            2,
+            error.provider.rawValue,
+            -1,
+            unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(
+            statement,
+            3,
+            error.errorType.rawValue,
+            -1,
+            unsafeBitCast(-1, to: sqlite3_destructor_type.self))
 
         if let message = error.errorMessage {
             sqlite3_bind_text(statement, 4, message, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
@@ -255,7 +273,7 @@ public final class PerformanceStorageImpl {
         sqlite3_bind_double(statement, 6, error.timestamp.timeIntervalSince1970)
 
         guard sqlite3_step(statement) == SQLITE_DONE else {
-            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(db)))
+            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
     }
 
@@ -264,17 +282,17 @@ public final class PerformanceStorageImpl {
     public func fetchDailyStats(
         timeRange: Int,
         provider: UsageProvider? = nil,
-        model: String? = nil
-    ) async throws -> [DailyPerformanceStats] {
-        try open()
+        model: String? = nil) async throws -> [DailyPerformanceStats]
+    {
+        try self.open()
 
         var sql = "SELECT * FROM daily_stats WHERE date >= date('now', '-\(timeRange) days')"
 
-        if let provider = provider {
+        if let provider {
             sql += " AND provider = '\(provider.rawValue)'"
         }
 
-        if let model = model {
+        if let model {
             sql += " AND model = '\(model)'"
         }
 
@@ -283,8 +301,8 @@ public final class PerformanceStorageImpl {
         var statement: OpaquePointer?
         defer { sqlite3_finalize(statement) }
 
-        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
-            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        guard sqlite3_prepare_v2(self.db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(self.db)))
         }
 
         var stats: [DailyPerformanceStats] = []
@@ -337,8 +355,7 @@ public final class PerformanceStorageImpl {
                 quotaCount: quotaCount,
                 networkCount: networkCount,
                 apiErrorCount: apiErrorCount,
-                createdAt: createdAt
-            )
+                createdAt: createdAt)
 
             stats.append(stat)
         }
@@ -349,12 +366,12 @@ public final class PerformanceStorageImpl {
     // MARK: - Database Maintenance
 
     public func vacuum() async throws {
-        try open()
-        try execute("VACUUM")
+        try self.open()
+        try self.execute("VACUUM")
     }
 
     public func deleteOldData(olderThan days: Int) async throws {
-        try open()
+        try self.open()
 
         let cutoffDate = Date().addingTimeInterval(-Double(days) * 24 * 60 * 60)
         let cutoffTimestamp = cutoffDate.timeIntervalSince1970
@@ -362,11 +379,11 @@ public final class PerformanceStorageImpl {
         let queries = [
             "DELETE FROM latency_metrics WHERE created_at < \(cutoffTimestamp)",
             "DELETE FROM quality_ratings WHERE timestamp < \(cutoffTimestamp)",
-            "DELETE FROM error_events WHERE timestamp < \(cutoffTimestamp)"
+            "DELETE FROM error_events WHERE timestamp < \(cutoffTimestamp)",
         ]
 
         for query in queries {
-            try execute(query)
+            try self.execute(query)
         }
     }
 
@@ -382,15 +399,15 @@ public final class PerformanceStorageImpl {
         public var errorDescription: String? {
             switch self {
             case .notOpen:
-                return "Database not open"
-            case .openFailed(let message):
-                return "Failed to open database: \(message)"
-            case .prepareFailed(let message):
-                return "Failed to prepare statement: \(message)"
-            case .executionFailed(let message):
-                return "Failed to execute statement: \(message)"
-            case .insertFailed(let message):
-                return "Failed to insert data: \(message)"
+                "Database not open"
+            case let .openFailed(message):
+                "Failed to open database: \(message)"
+            case let .prepareFailed(message):
+                "Failed to prepare statement: \(message)"
+            case let .executionFailed(message):
+                "Failed to execute statement: \(message)"
+            case let .insertFailed(message):
+                "Failed to insert data: \(message)"
             }
         }
     }
@@ -400,7 +417,7 @@ public final class PerformanceStorageImpl {
 
 extension String {
     fileprivate init(cString pointer: UnsafePointer<UInt8>?) {
-        guard let pointer = pointer else {
+        guard let pointer else {
             self = ""
             return
         }

package/Sources/RunicCore/Policy/UsagePolicyEngine.swift

@@ -145,7 +145,7 @@ public enum UsagePolicyEngine {
         context: UsagePolicyContext) -> String?
     {
         switch condition {
-        case .projectedBudgetOverrun(let minimumPercent):
+        case let .projectedBudgetOverrun(minimumPercent):
             guard let budget = context.budgetLimitUSD, budget > 0 else { return nil }
             guard let projected = context.projectedSpendUSD, projected.isFinite else { return nil }
             let overrunUSD = projected - budget
@@ -161,7 +161,7 @@ public enum UsagePolicyEngine {
             guard observed >= budget else { return nil }
             return "Observed spend \(UsageFormatter.usdString(observed)) reached budget \(UsageFormatter.usdString(budget))."
 
-        case .anomalySeverityAtLeast(let required):
+        case let .anomalySeverityAtLeast(required):
             guard let observed = context.anomalySeverity else { return nil }
             guard observed.rawValue >= required.rawValue else { return nil }
             return "Anomaly severity \(self.severityLabel(observed)) meets threshold \(self.severityLabel(required))."

package/Sources/RunicCore/ProjectBudgetStore.swift

@@ -2,11 +2,14 @@ import Foundation
 import RunicCore
 
 /// Storage for project budget limits and alert thresholds
-public struct ProjectBudgetStore {
+public enum ProjectBudgetStore {
     // MARK: - Types
 
     public struct ProjectBudget: Codable, Sendable, Identifiable {
-        public var id: String { projectID }
+        public var id: String {
+            self.projectID
+        }
+
         public let projectID: String
         public var projectName: String?
         public var monthlyLimit: Double
@@ -20,8 +23,8 @@ public struct ProjectBudgetStore {
             monthlyLimit: Double,
             alertThreshold: Double = 0.8,
             enabled: Bool = true,
-            createdAt: Date = Date()
-        ) {
+            createdAt: Date = Date())
+        {
             self.projectID = projectID
             self.projectName = projectName
             self.monthlyLimit = monthlyLimit
@@ -53,7 +56,7 @@ public struct ProjectBudgetStore {
     // MARK: - Public Methods
 
     public static func load() -> BudgetsData {
-        guard FileManager.default.fileExists(atPath: storageURL.path) else {
+        guard FileManager.default.fileExists(atPath: self.storageURL.path) else {
             return BudgetsData()
         }
 
@@ -74,26 +77,26 @@ public struct ProjectBudgetStore {
         encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
 
         let data = try encoder.encode(budgetsData)
-        try data.write(to: storageURL, options: .atomic)
+        try data.write(to: self.storageURL, options: .atomic)
     }
 
     public static func getBudget(projectID: String) -> ProjectBudget? {
-        load().budgets[projectID]
+        self.load().budgets[projectID]
     }
 
     public static func setBudget(_ budget: ProjectBudget) throws {
-        var data = load()
+        var data = self.load()
         data.budgets[budget.projectID] = budget
-        try save(data)
+        try self.save(data)
     }
 
     public static func removeBudget(projectID: String) throws {
-        var data = load()
+        var data = self.load()
         data.budgets.removeValue(forKey: projectID)
-        try save(data)
+        try self.save(data)
     }
 
     public static func getAllBudgets() -> [ProjectBudget] {
-        Array(load().budgets.values).sorted { $0.createdAt < $1.createdAt }
+        Array(self.load().budgets.values).sorted { $0.createdAt < $1.createdAt }
     }
 }

package/Sources/RunicCore/Providers/Antigravity/AntigravityProviderDescriptor.swift

@@ -1,5 +1,5 @@
-import RunicMacroSupport
 import Foundation
+import RunicMacroSupport
 
 @ProviderDescriptorRegistration
 @ProviderDescriptorDefinition
@@ -49,7 +49,9 @@ struct AntigravityStatusFetchStrategy: ProviderFetchStrategy {
     let id: String = "antigravity.local"
     let kind: ProviderFetchKind = .localProbe
 
-    func isAvailable(_: ProviderFetchContext) async -> Bool { true }
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
 
     func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
         let probe = AntigravityStatusProbe()

package/Sources/RunicCore/Providers/Antigravity/AntigravityStatusProbe.swift

@@ -309,7 +309,7 @@ public struct AntigravityStatusProbe: Sendable {
 
     // MARK: - Port detection
 
-    private struct ProcessInfoResult: Sendable {
+    private struct ProcessInfoResult {
         let pid: Int
         let extensionPort: Int?
         let csrfToken: String
@@ -459,7 +459,7 @@ public struct AntigravityStatusProbe: Sendable {
         let body: [String: Any]
     }
 
-    private struct RequestContext: Sendable {
+    private struct RequestContext {
         let httpsPort: Int
         let httpPort: Int?
         let csrfToken: String

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

@@ -1,5 +1,5 @@
-import RunicMacroSupport
 import Foundation
+import RunicMacroSupport
 
 @ProviderDescriptorRegistration
 @ProviderDescriptorDefinition
@@ -71,7 +71,7 @@ struct AuggieAPIFetchStrategy: ProviderFetchStrategy {
     }
 }
 
-enum AuggieSettingsError: LocalizedError, Sendable {
+enum AuggieSettingsError: LocalizedError {
     case missingToken
 
     var errorDescription: String? {

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

@@ -1,6 +1,6 @@
 import Foundation
 
-struct AuggieUsageMetrics: Sendable {
+struct AuggieUsageMetrics {
     let requestCount: Int?
     let totalTokens: Int?
     let inputTokens: Int?
@@ -46,7 +46,7 @@ struct AuggieUsageFetcher {
             URLQueryItem(name: "window", value: "day"),
             URLQueryItem(name: "days", value: "1"),
         ]
-        let url = components?.url ?? baseURL
+        let url = components?.url ?? self.baseURL
 
         var request = URLRequest(url: url)
         request.timeoutInterval = Self.requestTimeout
@@ -121,7 +121,7 @@ struct AuggieUsageFetcher {
     }
 }
 
-enum AuggieAPIError: LocalizedError, Sendable {
+enum AuggieAPIError: LocalizedError {
     case invalidResponse
     case decodingError
     case httpError(statusCode: Int, body: String?)

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

@@ -1,5 +1,5 @@
-import RunicMacroSupport
 import Foundation
+import RunicMacroSupport
 
 @ProviderDescriptorRegistration
 @ProviderDescriptorDefinition
@@ -78,14 +78,14 @@ struct AzureOpenAIAPIFetchStrategy: ProviderFetchStrategy {
     }
 
     private static func resolveToken(context: ProviderFetchContext) -> ProviderTokenResolution? {
-        if let token = Self.cleaned(context.settings?.azure?.apiToken) {
+        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 = Self.cleaned(context.settings?.azure?.endpoint) {
+        if let endpoint = cleaned(context.settings?.azure?.endpoint) {
             return endpoint
         }
         if let endpoint = Self.cleaned(context.env["AZURE_OPENAI_ENDPOINT"]) {
@@ -98,7 +98,7 @@ struct AzureOpenAIAPIFetchStrategy: ProviderFetchStrategy {
     }
 
     private static func resolveAPIVersion(context: ProviderFetchContext) -> String {
-        if let version = Self.cleaned(context.settings?.azure?.apiVersion) {
+        if let version = cleaned(context.settings?.azure?.apiVersion) {
             return version
         }
         if let version = Self.cleaned(context.env["AZURE_OPENAI_API_VERSION"]) {
@@ -108,7 +108,7 @@ struct AzureOpenAIAPIFetchStrategy: ProviderFetchStrategy {
     }
 
     private static func resolveDeployment(context: ProviderFetchContext) -> String? {
-        if let deployment = Self.cleaned(context.settings?.azure?.deployment) {
+        if let deployment = cleaned(context.settings?.azure?.deployment) {
             return deployment
         }
         if let deployment = Self.cleaned(context.env["AZURE_OPENAI_DEPLOYMENT"]) {
@@ -124,17 +124,17 @@ struct AzureOpenAIAPIFetchStrategy: ProviderFetchStrategy {
     }
 }
 
-enum AzureSettingsError: LocalizedError, Sendable {
+enum AzureSettingsError: LocalizedError {
     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 " +
+            "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 " +
+            "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,7 +1,7 @@
 import Foundation
 
 struct AzureOpenAIDeploymentsResponse: Decodable {
-    struct Deployment: Decodable, Sendable {
+    struct Deployment: Decodable {
         let id: String?
         let model: String?
         let status: String?
@@ -77,7 +77,7 @@ struct AzureUsageFetcher {
             throw AzureAPIError.invalidResponse
         }
 
-        guard (200 ..< 300).contains(httpResponse.statusCode) else {
+        guard (200..<300).contains(httpResponse.statusCode) else {
             let body = String(data: data, encoding: .utf8)?
                 .trimmingCharacters(in: .whitespacesAndNewlines)
             throw AzureAPIError.httpError(
@@ -94,6 +94,8 @@ struct AzureUsageFetcher {
         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 {
@@ -165,7 +167,7 @@ extension AzureOpenAIDeploymentsResponse {
     }
 }
 
-enum AzureAPIError: LocalizedError, Sendable {
+enum AzureAPIError: LocalizedError {
     case invalidEndpoint(String)
     case invalidResponse
     case httpError(statusCode: Int, body: String?)

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

@@ -1,5 +1,5 @@
-import RunicMacroSupport
 import Foundation
+import RunicMacroSupport
 
 @ProviderDescriptorRegistration
 @ProviderDescriptorDefinition
@@ -74,7 +74,7 @@ struct BedrockCLIFetchStrategy: ProviderFetchStrategy {
     }
 
     private static func resolveRegion(context: ProviderFetchContext) -> String? {
-        if let region = Self.cleaned(context.settings?.bedrock?.region) {
+        if let region = cleaned(context.settings?.bedrock?.region) {
             return region
         }
         if let region = Self.cleaned(context.env["AWS_REGION"]) {
@@ -87,7 +87,7 @@ struct BedrockCLIFetchStrategy: ProviderFetchStrategy {
     }
 
     private static func resolveProfile(context: ProviderFetchContext) -> String? {
-        if let profile = Self.cleaned(context.settings?.bedrock?.profile) {
+        if let profile = cleaned(context.settings?.bedrock?.profile) {
             return profile
         }
         if let profile = Self.cleaned(context.env["AWS_PROFILE"]) {
@@ -97,7 +97,7 @@ struct BedrockCLIFetchStrategy: ProviderFetchStrategy {
     }
 
     private static func resolveModelFilter(context: ProviderFetchContext) -> String? {
-        if let model = Self.cleaned(context.settings?.bedrock?.modelID) {
+        if let model = cleaned(context.settings?.bedrock?.modelID) {
             return model
         }
         if let model = Self.cleaned(context.env["BEDROCK_MODEL_ID"]) {
@@ -113,13 +113,13 @@ struct BedrockCLIFetchStrategy: ProviderFetchStrategy {
     }
 }
 
-enum BedrockSettingsError: LocalizedError, Sendable {
+enum BedrockSettingsError: LocalizedError {
     case missingRegion
 
     var errorDescription: String? {
         switch self {
         case .missingRegion:
-            return "AWS region not found. Set it in Preferences → Providers → Amazon Bedrock or " +
+            "AWS region not found. Set it in Preferences → Providers → Amazon Bedrock or " +
                 "export AWS_REGION."
         }
     }