Fix Kimi subscription quota rows (#1953)

Update Kimi membership quota enrichment to the current endpoint, add the Code 7-day quota, harden ratio validation, and preserve compact widget fit.

Co-authored-by: skyzer <skyzer@gmail.com>

Author: steipete

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Added
 - Widgets: make Kimi available with Weekly, Rate Limit, and Monthly quota rows. Thanks @joeVenner!
+- Kimi: show the subscription 7-day Code quota in menus and large widgets. Thanks @skyzer!
 
 ### Fixed
 - Amp: open the current Usage page from the menu dashboard action. Thanks @3kh0!
@@ -18,6 +19,7 @@
 - Devin: keep exact 1% usage from being inflated to 100% while preserving fractional fallback quota semantics. Thanks @Lex-ic-on!
 - Kimi K2: reject invalid and out-of-range numeric timestamps while preserving valid second and millisecond values. Thanks @joeVenner!
 - Kimi K2: reject non-finite credit and token values before they reach menus, CLI output, or widgets. Thanks @joeVenner!
+- Kimi: call the current `GetSubscriptionStats` membership endpoint so the Monthly subscription quota is populated again. Thanks @skyzer!
 - Kimi: show the five-hour rate limit before the weekly quota while preserving existing menu-bar metric preferences. Thanks @Zihao-Qi!
 
 ## 0.40.0 — 2026-07-05

Sources/CodexBar/UsageStore+WidgetSnapshot.swift

@@ -181,14 +181,17 @@ extension UsageStore {
                 title: metadata?.opusLabel ?? "Opus",
                 percentLeft: snapshot.tertiary?.remainingPercent))
         }
-        if provider == .kimi,
-           let monthly = snapshot.extraRateWindows?.first(where: { $0.id == "kimi-monthly" }),
-           monthly.usageKnown
-        {
-            rows.append(WidgetSnapshot.WidgetUsageRowSnapshot(
-                id: monthly.id,
-                title: monthly.title,
-                percentLeft: monthly.window.remainingPercent))
+        if provider == .kimi {
+            // Keep persisted widget order stable and include only Kimi's intentional subscription lanes.
+            let kimiWindowIDs = ["kimi-monthly", "kimi-code-7d"]
+            rows.append(contentsOf: kimiWindowIDs.compactMap { id in
+                guard let window = snapshot.extraRateWindows?.first(where: { $0.id == id }), window.usageKnown
+                else { return nil }
+                return WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: window.id,
+                    title: window.title,
+                    percentLeft: window.window.remainingPercent)
+            })
         }
         return rows.filter { $0.percentLeft != nil }
     }

Sources/CodexBarCore/Providers/Kimi/KimiModels.swift

@@ -9,8 +9,9 @@ struct KimiCodeAPIUsageResponse: Codable {
     let limits: [KimiRateLimit]?
 }
 
-struct KimiSubscriptionStatResponse: Codable {
+struct KimiSubscriptionStatsResponse: Codable {
     let subscriptionBalance: KimiSubscriptionBalance?
+    let ratelimitCode7d: KimiSubscriptionRateLimit?
 }
 
 struct KimiSubscriptionBalance: Codable, Sendable {
@@ -20,6 +21,12 @@ struct KimiSubscriptionBalance: Codable, Sendable {
     let expireTime: String?
 }
 
+struct KimiSubscriptionRateLimit: Codable, Sendable {
+    let ratio: Double?
+    let enabled: Bool?
+    let resetTime: String?
+}
+
 struct KimiUsage: Codable {
     let scope: String
     let detail: KimiUsageDetail

Sources/CodexBarCore/Providers/Kimi/KimiUsageFetcher.swift

@@ -9,8 +9,8 @@ public struct KimiUsageFetcher: Sendable {
     private static let subscriptionGraceSeconds: TimeInterval = 2
     private static let usageURL =
         URL(string: "https://www.kimi.com/apiv2/kimi.gateway.billing.v1.BillingService/GetUsages")!
-    private static let subscriptionStatURL =
-        URL(string: "https://www.kimi.com/apiv2/kimi.gateway.membership.v2.MembershipService/GetSubscriptionStat")!
+    private static let subscriptionStatsURL =
+        URL(string: "https://www.kimi.com/apiv2/kimi.gateway.membership.v2.MembershipService/GetSubscriptionStats")!
 
     public static func fetchCodeAPIUsage(
         apiKey: String,
@@ -83,8 +83,8 @@ public struct KimiUsageFetcher: Sendable {
     {
         let sessionInfo = self.decodeSessionInfo(from: authToken)
 
-        let subscriptionTask = Task<KimiSubscriptionStatResponse?, Error> {
-            try await self.fetchSubscriptionStat(
+        let subscriptionTask = Task<KimiSubscriptionStatsResponse?, Error> {
+            try await self.fetchSubscriptionStats(
                 authToken: authToken,
                 sessionInfo: sessionInfo,
                 transport: transport)
@@ -117,22 +117,23 @@ public struct KimiUsageFetcher: Sendable {
         }
         try Task.checkCancellation()
 
-        let subscriptionStat: KimiSubscriptionStatResponse?
+        let subscriptionStats: KimiSubscriptionStatsResponse?
         switch subscriptionOutcome {
         case let .value(response):
-            subscriptionStat = response
+            subscriptionStats = response
         case .timedOut:
-            Self.log.warning("Kimi subscription stat timed out")
-            subscriptionStat = nil
+            Self.log.warning("Kimi subscription stats timed out")
+            subscriptionStats = nil
         case let .failure(error):
-            Self.log.warning("Kimi subscription stat unavailable: \(error.localizedDescription)")
-            subscriptionStat = nil
+            Self.log.warning("Kimi subscription stats unavailable: \(error.localizedDescription)")
+            subscriptionStats = nil
         }
 
         return KimiUsageSnapshot(
             weekly: codingUsage.detail,
             rateLimit: codingUsage.limits?.first?.detail,
-            subscriptionBalance: subscriptionStat?.subscriptionBalance,
+            subscriptionBalance: subscriptionStats?.subscriptionBalance,
+            subscriptionCodeWeeklyLimit: subscriptionStats?.ratelimitCode7d,
             updatedAt: now)
     }
 
@@ -196,26 +197,26 @@ public struct KimiUsageFetcher: Sendable {
             .appendingPathComponent("usages")
     }
 
-    private static func fetchSubscriptionStat(
+    private static func fetchSubscriptionStats(
         authToken: String,
         sessionInfo: SessionInfo?,
-        transport: any ProviderHTTPTransport) async throws -> KimiSubscriptionStatResponse?
+        transport: any ProviderHTTPTransport) async throws -> KimiSubscriptionStatsResponse?
     {
-        var request = self.webRequest(url: self.subscriptionStatURL, authToken: authToken, sessionInfo: sessionInfo)
+        var request = self.webRequest(url: self.subscriptionStatsURL, authToken: authToken, sessionInfo: sessionInfo)
         request.httpBody = Data("{}".utf8)
 
         do {
             let response = try await transport.response(for: request)
             guard response.statusCode == 200 else {
-                Self.log.warning("Kimi subscription stat returned \(response.statusCode)")
+                Self.log.warning("Kimi subscription stats returned \(response.statusCode)")
                 return nil
             }
-            return try JSONDecoder().decode(KimiSubscriptionStatResponse.self, from: response.data)
+            return try JSONDecoder().decode(KimiSubscriptionStatsResponse.self, from: response.data)
         } catch {
             if error is CancellationError || (error as? URLError)?.code == .cancelled || Task.isCancelled {
                 throw CancellationError()
             }
-            Self.log.warning("Kimi subscription stat unavailable: \(error.localizedDescription)")
+            Self.log.warning("Kimi subscription stats unavailable: \(error.localizedDescription)")
             return nil
         }
     }

Sources/CodexBarCore/Providers/Kimi/KimiUsageSnapshot.swift

@@ -5,23 +5,27 @@ public struct KimiUsageSnapshot: Sendable {
     public let rateLimit: KimiUsageDetail?
     public let updatedAt: Date
     let subscriptionBalance: KimiSubscriptionBalance?
+    let subscriptionCodeWeeklyLimit: KimiSubscriptionRateLimit?
 
     public init(weekly: KimiUsageDetail, rateLimit: KimiUsageDetail?, updatedAt: Date) {
         self.weekly = weekly
         self.rateLimit = rateLimit
         self.updatedAt = updatedAt
         self.subscriptionBalance = nil
+        self.subscriptionCodeWeeklyLimit = nil
     }
 
     init(
         weekly: KimiUsageDetail,
         rateLimit: KimiUsageDetail?,
         subscriptionBalance: KimiSubscriptionBalance?,
+        subscriptionCodeWeeklyLimit: KimiSubscriptionRateLimit? = nil,
         updatedAt: Date)
     {
         self.weekly = weekly
         self.rateLimit = rateLimit
         self.subscriptionBalance = subscriptionBalance
+        self.subscriptionCodeWeeklyLimit = subscriptionCodeWeeklyLimit
         self.updatedAt = updatedAt
     }
 
@@ -91,7 +95,7 @@ extension KimiUsageSnapshot {
             // the pool is shared across features, so amountUsedRatio is the real "subscription remaining".
             guard balance.feature == nil || balance.feature == "FEATURE_OMNI" else { return nil }
             guard balance.type == nil || balance.type == "SUBSCRIPTION" else { return nil }
-            guard let ratio = balance.amountUsedRatio else { return nil }
+            guard let ratio = balance.amountUsedRatio, ratio.isFinite else { return nil }
             let window = RateWindow(
                 usedPercent: Self.clampedPercent(ratio * 100),
                 windowMinutes: nil,
@@ -100,6 +104,19 @@ extension KimiUsageSnapshot {
             return NamedRateWindow(id: "kimi-monthly", title: "Monthly", window: window)
         }
 
+        let subscriptionCodeWeeklyWindow = self.subscriptionCodeWeeklyLimit.flatMap { limit -> NamedRateWindow? in
+            guard limit.enabled != false else { return nil }
+            guard let ratio = limit.ratio, ratio.isFinite else { return nil }
+            let window = RateWindow(
+                usedPercent: Self.clampedPercent(ratio * 100),
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: Self.parseDate(limit.resetTime),
+                resetDescription: nil)
+            return NamedRateWindow(id: "kimi-code-7d", title: "Code 7-day", window: window)
+        }
+
+        let extraRateWindows = [monthlyWindow, subscriptionCodeWeeklyWindow].compactMap(\.self)
+
         let identity = ProviderIdentitySnapshot(
             providerID: .kimi,
             accountEmail: nil,
@@ -110,7 +127,7 @@ extension KimiUsageSnapshot {
             primary: weeklyWindow,
             secondary: rateLimitWindow,
             tertiary: nil,
-            extraRateWindows: monthlyWindow.map { [$0] },
+            extraRateWindows: extraRateWindows.isEmpty ? nil : extraRateWindows,
             providerCost: nil,
             updatedAt: self.updatedAt,
             identity: identity)

Tests/CodexBarTests/CodexBarWidgetProviderTests.swift

@@ -376,7 +376,7 @@ struct CodexBarWidgetProviderTests {
     }
 
     @Test
-    func `small and medium Kimi widgets keep all three persisted lane rows`() {
+    func `compact Kimi widgets keep established row fit while large widgets show all quotas`() {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let entry = WidgetSnapshot.ProviderEntry(
             provider: .kimi,
@@ -388,6 +388,7 @@ struct CodexBarWidgetProviderTests {
                 WidgetSnapshot.WidgetUsageRowSnapshot(id: "primary", title: "Weekly", percentLeft: 75),
                 WidgetSnapshot.WidgetUsageRowSnapshot(id: "secondary", title: "Rate Limit", percentLeft: 50),
                 WidgetSnapshot.WidgetUsageRowSnapshot(id: "kimi-monthly", title: "Monthly", percentLeft: 25),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "kimi-code-7d", title: "Code 7-day", percentLeft: 90),
             ],
             creditsRemaining: nil,
             codeReviewRemainingPercent: nil,
@@ -400,11 +401,13 @@ struct CodexBarWidgetProviderTests {
         let mediumRows = WidgetUsageRow.rows(
             for: entry,
             limit: WidgetUsageRow.mediumWidgetRowLimit(for: entry))
+        let largeRows = WidgetUsageRow.rows(for: entry)
 
         #expect(WidgetUsageRow.smallWidgetRowLimit(for: entry) == 3)
         #expect(WidgetUsageRow.mediumWidgetRowLimit(for: entry) == 3)
         #expect(smallRows.map(\.id) == ["primary", "secondary", "kimi-monthly"])
         #expect(mediumRows == smallRows)
+        #expect(largeRows.map(\.id) == ["primary", "secondary", "kimi-monthly", "kimi-code-7d"])
     }
 
     @Test

Tests/CodexBarTests/KimiProviderTests.swift

@@ -426,12 +426,15 @@ struct KimiUsageResponseParsingTests {
         }
         """
 
-        let response = try JSONDecoder().decode(KimiSubscriptionStatResponse.self, from: Data(json.utf8))
+        let response = try JSONDecoder().decode(KimiSubscriptionStatsResponse.self, from: Data(json.utf8))
 
         #expect(response.subscriptionBalance?.feature == "FEATURE_OMNI")
         #expect(response.subscriptionBalance?.type == "SUBSCRIPTION")
         #expect(response.subscriptionBalance?.amountUsedRatio == 1)
         #expect(response.subscriptionBalance?.expireTime == "2026-07-23T00:00:00Z")
+        #expect(response.ratelimitCode7d?.ratio == 0.0946)
+        #expect(response.ratelimitCode7d?.enabled == true)
+        #expect(response.ratelimitCode7d?.resetTime == "2026-07-09T06:56:36.876796734Z")
     }
 
     @Test
@@ -511,6 +514,11 @@ struct KimiUsageResponseParsingTests {
             "type": "SUBSCRIPTION",
             "amountUsedRatio": 0.42,
             "expireTime": "2026-07-23T00:00:00Z"
+          },
+          "ratelimitCode7d": {
+            "ratio": 0.17,
+            "enabled": true,
+            "resetTime": "2026-07-13T15:28:00Z"
           }
         }
         """
@@ -524,17 +532,23 @@ struct KimiUsageResponseParsingTests {
             if url.path.hasSuffix("/GetUsages") {
                 return (Data(usageJSON.utf8), response)
             }
+            #expect(url.path.hasSuffix("/GetSubscriptionStats"))
             return (Data(subscriptionJSON.utf8), response)
         }
 
         let snapshot = try await KimiUsageFetcher._fetchUsageForTesting(
             authToken: "test-token",
             transport: transport,
             subscriptionGrace: .seconds(1))
-        let monthly = try #require(snapshot.toUsageSnapshot().extraRateWindows?.first)
+        let windows = try #require(snapshot.toUsageSnapshot().extraRateWindows)
+        let monthly = try #require(windows.first { $0.id == "kimi-monthly" })
+        let weeklyCode = try #require(windows.first { $0.id == "kimi-code-7d" })
 
         #expect(monthly.id == "kimi-monthly")
         #expect(monthly.window.usedPercent == 42)
+        #expect(weeklyCode.title == "Code 7-day")
+        #expect(weeklyCode.window.usedPercent == 17)
+        #expect(weeklyCode.window.windowMinutes == 7 * 24 * 60)
     }
 
     @Test
@@ -723,6 +737,64 @@ struct KimiUsageSnapshotConversionTests {
         #expect(abs(monthly.window.usedPercent - 77.16) < 0.0001)
     }
 
+    @Test
+    func `converts subscription code weekly limit to extra window`() throws {
+        let now = Date()
+        let weeklyDetail = KimiUsageDetail(
+            limit: "2048",
+            used: "375",
+            remaining: "1673",
+            resetTime: "2026-01-09T15:23:13.373329235Z")
+        let subscriptionCodeWeeklyLimit = KimiSubscriptionRateLimit(
+            ratio: 0.0946,
+            enabled: true,
+            resetTime: "2026-07-13T15:28:00Z")
+
+        let snapshot = KimiUsageSnapshot(
+            weekly: weeklyDetail,
+            rateLimit: nil,
+            subscriptionBalance: nil,
+            subscriptionCodeWeeklyLimit: subscriptionCodeWeeklyLimit,
+            updatedAt: now)
+        let usageSnapshot = snapshot.toUsageSnapshot()
+
+        let weeklyCode = try #require(usageSnapshot.extraRateWindows?.first)
+        #expect(weeklyCode.id == "kimi-code-7d")
+        #expect(weeklyCode.title == "Code 7-day")
+        #expect(abs(weeklyCode.window.usedPercent - 9.46) < 0.0001)
+        #expect(weeklyCode.window.windowMinutes == 7 * 24 * 60)
+        #expect(weeklyCode.window.resetsAt == Self.date("2026-07-13T15:28:00Z"))
+    }
+
+    @Test
+    func `omits disabled and nonfinite subscription quota ratios`() {
+        let weeklyDetail = KimiUsageDetail(
+            limit: "2048",
+            used: "375",
+            remaining: "1673",
+            resetTime: "2026-01-09T15:23:13.373329235Z")
+        let invalidLimits = [
+            KimiSubscriptionRateLimit(ratio: 0.25, enabled: false, resetTime: nil),
+            KimiSubscriptionRateLimit(ratio: .nan, enabled: true, resetTime: nil),
+            KimiSubscriptionRateLimit(ratio: .infinity, enabled: true, resetTime: nil),
+        ]
+
+        for limit in invalidLimits {
+            let snapshot = KimiUsageSnapshot(
+                weekly: weeklyDetail,
+                rateLimit: nil,
+                subscriptionBalance: KimiSubscriptionBalance(
+                    feature: "FEATURE_OMNI",
+                    type: "SUBSCRIPTION",
+                    amountUsedRatio: .nan,
+                    expireTime: nil),
+                subscriptionCodeWeeklyLimit: limit,
+                updatedAt: Date())
+
+            #expect(snapshot.toUsageSnapshot().extraRateWindows == nil)
+        }
+    }
+
     @Test
     func `converts to usage snapshot without rate limit`() {
         let now = Date()