@@ -7,11 +7,11 @@ import UserNotifications
77/// Posted when the user changes the refresh interval, so the app delegate can
88/// restart its timer with the new period.
99extension Notification.Name {
10− static let refreshIntervalDidChange = Notification.Name("com.ilyakooo0.hyper-credits-menubar.refreshIntervalDidChange")
10+ static let refreshIntervalDidChange = Notification.Name("soy.iko.usage-menubar.refreshIntervalDidChange")
1111}
1212
13−/// The direction the balance has moved over the most recent history points.
14−enum BalanceTrend {
13+/// The direction a metric has moved over the most recent history points.
14+enum MetricTrend {
1515 case increasing
1616 case decreasing
1717 case stable
@@ -29,10 +29,11 @@ enum BalanceTrend {
2929 }
3030}
3131
32−/// A single balance observation.
33−struct BalancePoint: Equatable {
32+/// A single metric observation — used for Hyper balance, Claude 5-hour %,
33+/// and z.ai 5-hour % alike.
34+struct MetricPoint: Equatable {
3435 let date: Date
35− let balance: Int
36+ let value: Int
3637}
3738
3839/// How often the balance is refreshed. Lives outside `ViewModel` so the view and
@@ -80,6 +81,24 @@ final class ViewModel: ObservableObject {
8081 /// The Claude plan the credentials belong to — `"pro"`, `"max"`, …
8182 @Published var claudePlan: String?
8283
84+ /// z.ai Coding Plan usage. `nil` when no z.ai API key has been entered, in which
85+ /// case the popover leaves the section out entirely.
86+ @Published var zaiUsage: ZaiUsageReport?
87+
88+ /// A human-readable error message from the z.ai fetch. Independent of
89+ /// `errorMessage` and `claudeError`: the three services fail separately.
90+ @Published var zaiError: String?
91+
92+ /// The z.ai API key draft bound to the text field. Two-way bound to the
93+ /// `SecureField`, so it changes on every keystroke — never fetch with it, use
94+ /// `activeZaiAPIKey`.
95+ @Published var zaiAPIKeyInput: String = ""
96+
97+ /// Whether Hyper is configured — i.e. there is an API key in the Keychain.
98+ /// Drives whether the `⚡` segment appears in the menu bar at all: an
99+ /// unconfigured service should not take up space in the title.
100+ @Published private(set) var hyperConfigured = false
101+
83102 /// The API key draft bound to the text field. Two-way bound to the `SecureField`,
84103 /// so it changes on every keystroke — never fetch with it, use `activeAPIKey`.
85104 @Published var apiKeyInput: String = ""
@@ -93,8 +112,20 @@ final class ViewModel: ObservableObject {
93112 /// Brief "✓ Copied" confirmation shown after copying the balance.
94113 @Published var copiedConfirmation: Bool = false
95114
115+ /// Brief "✓ Copied" confirmation shown after copying the Claude percentage.
116+ @Published var copiedClaudeConfirmation: Bool = false
117+
118+ /// Brief "✓ Copied" confirmation shown after copying the z.ai percentage.
119+ @Published var copiedZaiConfirmation: Bool = false
120+
96121 /// Successful balance observations from the last 24 hours, oldest first.
97− @Published private(set) var history: [BalancePoint] = []
122+ @Published private(set) var history: [MetricPoint] = []
123+
124+ /// Successful Claude 5-hour % observations from the last 24 hours, oldest first.
125+ @Published private(set) var claudeHistory: [MetricPoint] = []
126+
127+ /// Successful z.ai 5-hour % observations from the last 24 hours, oldest first.
128+ @Published private(set) var zaiHistory: [MetricPoint] = []
98129
99130 /// How often the balance is refreshed, in minutes. Persisted to `UserDefaults`;
100131 /// changing it posts `.refreshIntervalDidChange` so the app delegate can
@@ -125,8 +156,13 @@ final class ViewModel: ObservableObject {
125156 /// last-updated time and history out from under the user.
126157 private var activeAPIKey: String
127158
159+ /// The z.ai key requests actually go out with: what is in the Keychain, not what
160+ /// is currently in the text field. Same rationale as `activeAPIKey`.
161+ private var activeZaiAPIKey: String
162+
128163 private let checker: CreditsChecking
129164 private let claudeChecker: ClaudeUsageChecking
165+ private let zaiChecker: ZaiUsageChecking
130166 private let defaults: UserDefaults
131167
132168 /// The currently in-flight refresh task, if any. Used to cancel
@@ -140,6 +176,12 @@ final class ViewModel: ObservableObject {
140176 /// Resets `savedConfirmation`; same rationale as `copiedResetTask`.
141177 private var savedResetTask: Task<Void, Never>?
142178
179+ /// Resets `copiedClaudeConfirmation`; same rationale as `copiedResetTask`.
180+ private var copiedClaudeResetTask: Task<Void, Never>?
181+
182+ /// Resets `copiedZaiConfirmation`; same rationale as `copiedResetTask`.
183+ private var copiedZaiResetTask: Task<Void, Never>?
184+
143185 // MARK: - History Configuration
144186
145187 /// 24 hours at the shortest (1 minute) interval would overflow this, so the
@@ -147,17 +189,26 @@ final class ViewModel: ObservableObject {
147189 private static let maxHistoryEntries = 300
148190 private static let historyWindow: TimeInterval = 24 * 60 * 60
149191
192+ /// The threshold above which a usage percentage triggers a notification.
193+ private static let highUsageThreshold = 90
194+
150195 init(
151196 checker: CreditsChecking = CreditsChecker(),
152197 claudeChecker: ClaudeUsageChecking = ClaudeUsageClient(),
198+ zaiChecker: ZaiUsageChecking = ZaiUsageClient(),
153199 defaults: UserDefaults = .standard
154200 ) {
155201 self.checker = checker
156202 self.claudeChecker = claudeChecker
203+ self.zaiChecker = zaiChecker
157204 self.defaults = defaults
158205 let storedKey = KeychainHelper.load() ?? ""
159206 apiKeyInput = storedKey
160207 activeAPIKey = storedKey
208+ hyperConfigured = !storedKey.isEmpty
209+ let storedZaiKey = ZaiKeychainHelper.load() ?? ""
210+ zaiAPIKeyInput = storedZaiKey
211+ activeZaiAPIKey = storedZaiKey
161212 // Assigning in init doesn't fire didSet, so this load doesn't re-post
162213 // the change notification or write back to defaults.
163214 refreshIntervalMinutes = RefreshInterval.stored(in: defaults)
@@ -186,25 +237,88 @@ final class ViewModel: ObservableObject {
186237 balanceFormatter.string(from: NSNumber(value: value)) ?? "\(value)"
187238 }
188239
189− /// The text to show in the menu bar: `⚡…` while loading, `⚡?` when no balance, `⚡{balance}` otherwise.
240+ /// The text to show in the menu bar. Each configured provider contributes a
241+ /// segment prefixed with a provider emoji; segments are separated by ` · `
242+ /// (middle dot). Within a segment, windows are listed as bare percentages
243+ /// separated by spaces. An unconfigured service produces no segment.
244+ /// When z.ai is in peak hours, a 🔶 marker is appended to the z.ai segment.
190245 ///
191− /// Takes the balance and loading flag as parameters rather than reading the
192− /// properties: `@Published` publishes in `willSet`, so a Combine subscriber that
193− /// called back into the view model would see the *pre-change* value and render a
194− /// title one update behind.
195− static func statusBarText(balance: Int?, isLoading: Bool) -> String {
196− if isLoading && balance == nil {
197− return "⚡…"
246+ /// Example: `⚡42 · ⁕62% 8% · Z12% 3%🔶`
247+ ///
248+ /// Takes its values as parameters rather than reading the properties: `@Published`
249+ /// publishes in `willSet`, so a Combine subscriber that called back into the view
250+ /// model would see the *pre-change* value and render a title one update behind.
251+ static func statusBarText(
252+ balance: Int?,
253+ isLoading: Bool,
254+ hyperConfigured: Bool,
255+ claudeFiveHourPercent: Int?,
256+ claudeSevenDayPercent: Int?,
257+ zaiFiveHourPercent: Int?,
258+ zaiWeeklyPercent: Int?,
259+ zaiInPeakHours: Bool
260+ ) -> String {
261+ var segments: [String] = []
262+
263+ // Hyper
264+ if hyperConfigured, let balance = balance {
265+ segments.append("⚡\(formatBalance(balance))")
266+ }
267+
268+ // Claude — provider emoji + bare percentages
269+ var claudeWindows: [String] = []
270+ if let fiveHour = claudeFiveHourPercent {
271+ claudeWindows.append("\(fiveHour)%")
272+ }
273+ if let sevenDay = claudeSevenDayPercent {
274+ claudeWindows.append("\(sevenDay)%")
275+ }
276+ if !claudeWindows.isEmpty {
277+ segments.append("⁕" + claudeWindows.joined(separator: " "))
278+ }
279+
280+ // z.ai — provider emoji + bare percentages
281+ var zaiWindows: [String] = []
282+ if let zaiFiveHour = zaiFiveHourPercent {
283+ zaiWindows.append("\(zaiFiveHour)%")
284+ }
285+ if let zaiWeekly = zaiWeeklyPercent {
286+ zaiWindows.append("\(zaiWeekly)%")
198287 }
199− if let balance = balance {
200− return "⚡\(formatBalance(balance))"
288+ if !zaiWindows.isEmpty {
289+ var segment = "Z" + zaiWindows.joined(separator: " ")
290+ if zaiInPeakHours {
291+ segment += "🔶"
292+ }
293+ segments.append(segment)
294+ }
295+
296+ if segments.isEmpty {
297+ // No service is configured or has anything to show. While loading,
298+ // show an ellipsis; otherwise the title is empty.
299+ return isLoading ? "…" : ""
201300 }
202− return "⚡?"
301+ return segments.joined(separator: " · ")
203302 }
204303
205304 /// The text to show in the menu bar for the current state.
206305 var statusBarItemText: String {
207− Self.statusBarText(balance: balance, isLoading: isLoading)
306+ Self.statusBarText(
307+ balance: balance,
308+ isLoading: isLoading,
309+ hyperConfigured: hyperConfigured,
310+ claudeFiveHourPercent: claudeFiveHourPercent,
311+ claudeSevenDayPercent: claudeSevenDayPercent,
312+ zaiFiveHourPercent: zaiFiveHourPercent,
313+ zaiWeeklyPercent: zaiWeeklyPercent,
314+ zaiInPeakHours: Self.zaiInPeakHours
315+ )
316+ }
317+
318+ /// Whether z.ai is currently in peak hours (06:00–10:00 UTC).
319+ static var zaiInPeakHours: Bool {
320+ let hour = Calendar(identifier: .gregorian).component(.hour, from: Date())
321+ return hour >= 6 && hour < 10
208322 }
209323
210324 /// The formatted balance string for display in the popover.
@@ -227,76 +341,118 @@ final class ViewModel: ObservableObject {
227341 return "Updated \(Self.relativeFormatter.localizedString(for: lastUpdated, relativeTo: Date()))"
228342 }
229343
230− // MARK: - History
344+ // MARK: - History (Hyper)
231345
232− /// The last 24 hours of successful fetches, oldest first.
346+ /// The last 24 hours of successful balance fetches, oldest first.
233347 var balanceHistory: [(date: Date, balance: Int)] {
234− history.map { (date: $0.date, balance: $0.balance) }
348+ history.map { (date: $0.date, balance: $0.value) }
235349 }
236350
237351 /// The direction of travel across the most recent handful of observations.
238352 /// `.unknown` until there are at least two points to compare.
239− var balanceTrend: BalanceTrend {
240− guard history.count >= 2 else { return .unknown }
241− let recent = history.suffix(5)
353+ var balanceTrend: MetricTrend {
354+ metricTrend(history)
355+ }
356+
357+ /// The sparkline's data for the Hyper balance.
358+ var balanceSparklineValues: [Int] {
359+ history.map { $0.value }
360+ }
361+
362+ // MARK: - History (Claude)
363+
364+ /// The last 24 hours of successful Claude 5-hour % fetches, oldest first.
365+ var claudeSparklineValues: [Int] {
366+ claudeHistory.map { $0.value }
367+ }
368+
369+ /// The direction of travel for the Claude 5-hour %.
370+ var claudeTrend: MetricTrend {
371+ metricTrend(claudeHistory)
372+ }
373+
374+ // MARK: - History (z.ai)
375+
376+ /// The last 24 hours of successful z.ai 5-hour % fetches, oldest first.
377+ var zaiSparklineValues: [Int] {
378+ zaiHistory.map { $0.value }
379+ }
380+
381+ /// The direction of travel for the z.ai 5-hour %.
382+ var zaiTrend: MetricTrend {
383+ metricTrend(zaiHistory)
384+ }
385+
386+ // MARK: - History Helpers
387+
388+ /// Computes the trend from a generic history array.
389+ private func metricTrend(_ points: [MetricPoint]) -> MetricTrend {
390+ guard points.count >= 2 else { return .unknown }
391+ let recent = points.suffix(5)
242392 guard let first = recent.first, let last = recent.last else { return .unknown }
243− if last.balance > first.balance { return .increasing }
244− if last.balance < first.balance { return .decreasing }
393+ if last.value > first.value { return .increasing }
394+ if last.value < first.value { return .decreasing }
245395 return .stable
246396 }
247397
248398 /// Appends an observation and drops anything older than 24 hours or beyond the cap.
249− private func recordHistory(balance: Int, at date: Date) {
250− history.append(BalancePoint(date: date, balance: balance))
399+ private func recordMetric(_ value: Int, into array: inout [MetricPoint], at date: Date) {
400+ array.append(MetricPoint(date: date, value: value))
251401
252402 let cutoff = date.addingTimeInterval(-Self.historyWindow)
253− history.removeAll { $0.date < cutoff }
403+ array.removeAll { $0.date < cutoff }
254404
255− if history.count > Self.maxHistoryEntries {
256− history.removeFirst(history.count - Self.maxHistoryEntries)
405+ if array.count > Self.maxHistoryEntries {
406+ array.removeFirst(array.count - Self.maxHistoryEntries)
257407 }
258408 }
259409
260410 // MARK: - Refresh
261411
262− /// Refreshes the Hyper balance and the Claude usage, both at once.
412+ /// Refreshes the Hyper balance, the Claude usage, and the z.ai usage, all at once.
263413 ///
264− /// The two are independent: either can fail, or not be configured at all, without
265− /// touching the other. Cancels any previously in-flight refresh to prevent races.
414+ /// The three are independent: any can fail, or not be configured at all, without
415+ /// touching the others. Cancels any previously in-flight refresh to prevent races.
266416 func refresh() {
267417 refreshTask?.cancel()
268418
269419 // Deliberately the saved key rather than `apiKeyInput`: see `activeAPIKey`.
270420 let key = activeAPIKey
421+ let zaiKey = activeZaiAPIKey
271422 if key.isEmpty {
272423 // Nothing to fetch, and nothing worth keeping: the balance, its history and
273− // any error all belonged to a key that is no longer there. Claude is left
274− // alone — it doesn't depend on the Hyper key.
424+ // any error all belonged to a key that is no longer there. Claude and z.ai
425+ // are left alone — they don't depend on the Hyper key.
275426 balance = nil
276427 errorMessage = nil
277428 lastUpdated = nil
278429 history.removeAll()
279− isLoading = false
280430 }
281431
282432 refreshTask = Task { @MainActor in
283433 // Check cancellation before setting isLoading — a previous
284434 // refresh() may have cancelled us and already set isLoading = false.
285435 guard !Task.isCancelled else { return }
286− if !key.isEmpty { isLoading = true }
436+ // Loading state covers all fetches: the popover's loading view depends
437+ // on it, and Claude/z.ai usage is fetched even when there's no Hyper key.
438+ isLoading = true
287439 // Don't clear the errors here — keep showing the last one
288440 // until we have a successful result.
289441
290− // Both requests go out at once; neither waits on the other.
442+ // All three requests go out at once; none waits on the others.
291443 async let balanceOutcome = fetchBalance(key: key)
292444 async let claudeOutcome = fetchClaudeUsage()
445+ async let zaiOutcome = fetchZaiUsage(key: zaiKey)
293446
294447 let balanceResult = await balanceOutcome
295448 let claudeResult = await claudeOutcome
449+ let zaiResult = await zaiOutcome
296450 guard !Task.isCancelled else { return }
297451
298452 applyBalance(balanceResult)
299453 applyClaude(claudeResult)
454+ applyZai(zaiResult)
455+ isLoading = false
300456 }
301457 }
302458
@@ -322,7 +478,7 @@ final class ViewModel: ObservableObject {
322478 errorMessage = nil
323479 let now = Date()
324480 lastUpdated = now
325− recordHistory(balance: newBalance, at: now)
481+ recordMetric(newBalance, into: &history, at: now)
326482
327483 // Low-balance notification: on threshold crossing (≥10 → <10)
328484 // OR on first successful fetch if already below threshold.
@@ -338,8 +494,6 @@ final class ViewModel: ObservableObject {
338494 // (it's already nil in that case, so nothing to do).
339495 errorMessage = error.localizedDescription
340496 }
341−
342− isLoading = false
343497 }
344498
345499 // MARK: - Claude Usage
@@ -369,12 +523,30 @@ final class ViewModel: ObservableObject {
369523 claudeUsage = nil
370524 claudePlan = nil
371525 claudeError = nil
526+ claudeHistory.removeAll()
372527
373528 case .usage(let report):
529+ // Capture the previous 5-hour % for threshold-crossing notification.
530+ let previousPercent = claudeFiveHourPercent
374531 claudeUsage = report.usage
375532 claudePlan = report.subscriptionType
376533 claudeError = nil
377534
535+ // Record history and fire high-usage notification based on the 5-hour %.
536+ if let percent = claudeFiveHourPercent {
537+ let now = Date()
538+ recordMetric(percent, into: &claudeHistory, at: now)
539+
540+ // High-usage notification: on threshold crossing (<90 → ≥90)
541+ // OR on first successful fetch if already above threshold.
542+ if let previous = previousPercent, previous < Self.highUsageThreshold,
543+ percent >= Self.highUsageThreshold {
544+ sendHighUsageNotification(provider: "Claude Code", percent: percent)
545+ } else if previousPercent == nil, percent >= Self.highUsageThreshold {
546+ sendHighUsageNotification(provider: "Claude Code", percent: percent)
547+ }
548+ }
549+
378550 case .failure(let message):
379551 // As with the balance: keep the last good numbers on screen and say what
380552 // went wrong, rather than blanking the section on a transient failure.
@@ -382,6 +554,25 @@ final class ViewModel: ObservableObject {
382554 }
383555 }
384556
557+ /// The 5-hour window percentage for the menu bar title, or `nil` when absent.
558+ var claudeFiveHourPercent: Int? {
559+ guard let fiveHour = claudeUsage?.fiveHour else { return nil }
560+ return Int(fiveHour.utilization.rounded())
561+ }
562+
563+ /// The 7-day window percentage for the menu bar title, or `nil` when absent.
564+ /// Falls back to the 7-day Opus window when the regular 7-day is absent but Opus
565+ /// has been used — on Max plans the Opus cap is the one that binds first.
566+ var claudeSevenDayPercent: Int? {
567+ if let sevenDay = claudeUsage?.sevenDay {
568+ return Int(sevenDay.utilization.rounded())
569+ }
570+ if let opus = claudeUsage?.sevenDayOpus, opus.utilization > 0 {
571+ return Int(opus.utilization.rounded())
572+ }
573+ return nil
574+ }
575+
385576 /// Display label for the Claude plan, e.g. "Pro" or "Max".
386577 var claudePlanLabel: String? {
387578 guard let plan = claudePlan?.trimmingCharacters(in: .whitespacesAndNewlines),
@@ -397,6 +588,88 @@ final class ViewModel: ObservableObject {
397588 }
398589 }
399590
591+ // MARK: - z.ai Usage
592+
593+ /// What a z.ai fetch produced. Missing API key is deliberately not a failure:
594+ /// plenty of people don't use z.ai, and an error telling them so would be noise.
595+ private enum ZaiOutcome {
596+ case notConfigured
597+ case usage(ZaiUsageReport)
598+ case failure(String)
599+ }
600+
601+ private func fetchZaiUsage(key: String) async -> ZaiOutcome {
602+ guard !key.isEmpty else { return .notConfigured }
603+ do {
604+ return .usage(try await zaiChecker.fetchUsage(apiKey: key))
605+ } catch ZaiUsageError.noAPIKey {
606+ return .notConfigured
607+ } catch {
608+ return .failure(error.localizedDescription)
609+ }
610+ }
611+
612+ private func applyZai(_ outcome: ZaiOutcome) {
613+ switch outcome {
614+ case .notConfigured:
615+ zaiUsage = nil
616+ zaiError = nil
617+ zaiHistory.removeAll()
618+
619+ case .usage(let report):
620+ // Capture the previous 5-hour % for threshold-crossing notification.
621+ let previousPercent = zaiFiveHourPercent
622+ zaiUsage = report
623+ zaiError = nil
624+
625+ // Record history and fire high-usage notification based on the 5-hour %.
626+ if let percent = zaiFiveHourPercent {
627+ let now = Date()
628+ recordMetric(percent, into: &zaiHistory, at: now)
629+
630+ // High-usage notification: on threshold crossing (<90 → ≥90)
631+ // OR on first successful fetch if already above threshold.
632+ if let previous = previousPercent, previous < Self.highUsageThreshold,
633+ percent >= Self.highUsageThreshold {
634+ sendHighUsageNotification(provider: "z.ai Coding", percent: percent)
635+ } else if previousPercent == nil, percent >= Self.highUsageThreshold {
636+ sendHighUsageNotification(provider: "z.ai Coding", percent: percent)
637+ }
638+ }
639+
640+ case .failure(let message):
641+ // As with the balance and Claude: keep the last good numbers on screen
642+ // and say what went wrong, rather than blanking the section on a
643+ // transient failure.
644+ zaiError = message
645+ }
646+ }
647+
648+ /// The 5-hour window percentage for the menu bar title, or `nil` when absent.
649+ var zaiFiveHourPercent: Int? {
650+ zaiUsage?.fiveHourPercent
651+ }
652+
653+ /// The weekly window percentage for the popover, or `nil` when absent.
654+ var zaiWeeklyPercent: Int? {
655+ zaiUsage?.weeklyPercent
656+ }
657+
658+ /// Display label for the z.ai plan, e.g. "Lite", "Pro", or "Max".
659+ /// Falls back to the raw `planLevel` string if it doesn't match a known tier.
660+ var zaiPlanLabel: String? {
661+ guard let level = zaiUsage?.planLevel?.trimmingCharacters(in: .whitespacesAndNewlines),
662+ !level.isEmpty else { return nil }
663+
664+ // The subscription endpoint returns a product name like "GLM Coding Max";
665+ // extract the tier from it. The quota endpoint returns just the tier.
666+ let lowered = level.lowercased()
667+ if lowered.contains("max") { return "Max" }
668+ if lowered.contains("pro") { return "Pro" }
669+ if lowered.contains("lite") { return "Lite" }
670+ return level.capitalized
671+ }
672+
400673 // MARK: - Clipboard
401674
402675 /// Copies the current balance to the clipboard as plain digits (no grouping
@@ -417,7 +690,41 @@ final class ViewModel: ObservableObject {
417690 }
418691 }
419692
420− // MARK: - Low Balance Notification
693+ /// Copies the current Claude 5-hour percentage to the clipboard.
694+ func copyClaudePercentToClipboard() {
695+ guard let percent = claudeFiveHourPercent else { return }
696+
697+ let pasteboard = NSPasteboard.general
698+ pasteboard.clearContents()
699+ pasteboard.setString("\(percent)%", forType: .string)
700+
701+ copiedClaudeConfirmation = true
702+ copiedClaudeResetTask?.cancel()
703+ copiedClaudeResetTask = Task { @MainActor in
704+ try? await Task.sleep(nanoseconds: 1_500_000_000)
705+ guard !Task.isCancelled else { return }
706+ copiedClaudeConfirmation = false
707+ }
708+ }
709+
710+ /// Copies the current z.ai 5-hour percentage to the clipboard.
711+ func copyZaiPercentToClipboard() {
712+ guard let percent = zaiFiveHourPercent else { return }
713+
714+ let pasteboard = NSPasteboard.general
715+ pasteboard.clearContents()
716+ pasteboard.setString("\(percent)%", forType: .string)
717+
718+ copiedZaiConfirmation = true
719+ copiedZaiResetTask?.cancel()
720+ copiedZaiResetTask = Task { @MainActor in
721+ try? await Task.sleep(nanoseconds: 1_500_000_000)
722+ guard !Task.isCancelled else { return }
723+ copiedZaiConfirmation = false
724+ }
725+ }
726+
727+ // MARK: - Notifications
421728
422729 private func sendLowBalanceNotification(balance: Int) {
423730 // Build the body here, on the main actor. `getNotificationSettings` calls back on
@@ -431,7 +738,7 @@ final class ViewModel: ObservableObject {
431738 return
432739 }
433740 let content = UNMutableNotificationContent()
434− content.title = "Low Hyper Credits"
741+ content.title = "Low Usage Menubar"
435742 content.body = body
436743 content.sound = .default
437744
@@ -446,6 +753,29 @@ final class ViewModel: ObservableObject {
446753 }
447754 }
448755
756+ /// Sends a notification when a usage percentage crosses the high-usage threshold.
757+ private func sendHighUsageNotification(provider: String, percent: Int) {
758+ let body = "\(provider) 5-hour usage at \(percent)% — approaching limit"
759+
760+ let center = UNUserNotificationCenter.current()
761+ center.getNotificationSettings { settings in
762+ guard settings.authorizationStatus == .authorized || settings.authorizationStatus == .provisional else {
763+ return
764+ }
765+ let content = UNMutableNotificationContent()
766+ content.title = "High Usage Menubar"
767+ content.body = body
768+ content.sound = .default
769+
770+ let request = UNNotificationRequest(
771+ identifier: "high-usage-alert-\(provider)-\(UUID().uuidString)",
772+ content: content,
773+ trigger: nil
774+ )
775+ center.add(request)
776+ }
777+ }
778+
449779 // MARK: - API Key
450780
451781 /// Saves the current `apiKeyInput` to the Keychain and triggers a refresh.
@@ -460,6 +790,7 @@ final class ViewModel: ObservableObject {
460790 }
461791 apiKeyInput = ""
462792 activeAPIKey = ""
793+ hyperConfigured = false
463794 // refresh() with an empty key clears balance, error, history, and
464795 // cancels any in-flight task from the previous key.
465796 refresh()
@@ -483,6 +814,7 @@ final class ViewModel: ObservableObject {
483814 // Show the trimmed key that was actually stored.
484815 apiKeyInput = key
485816 activeAPIKey = key
817+ hyperConfigured = true
486818 refresh()
487819 }
488820
@@ -498,6 +830,53 @@ final class ViewModel: ObservableObject {
498830 }
499831 }
500832
833+ // MARK: - z.ai API Key
834+
835+ /// Saves the current `zaiAPIKeyInput` to the Keychain and triggers a refresh.
836+ /// Shows "✓ Saved" on success, or an error message if the keychain rejected the key.
837+ func saveZaiAPIKey() {
838+ let key = zaiAPIKeyInput.trimmingCharacters(in: .whitespacesAndNewlines)
839+ if key.isEmpty {
840+ let deleted = ZaiKeychainHelper.delete()
841+ guard deleted else {
842+ zaiError = "Could not delete z.ai API key from Keychain. It may be locked."
843+ return
844+ }
845+ zaiAPIKeyInput = ""
846+ activeZaiAPIKey = ""
847+ // refresh() with an empty key clears zai usage and error, and
848+ // cancels any in-flight task from the previous key.
849+ refresh()
850+ } else {
851+ let saved = ZaiKeychainHelper.save(key)
852+ guard saved else {
853+ zaiError = "Could not save z.ai API key to Keychain. It may be locked."
854+ return
855+ }
856+ // A different key is a different account, so everything derived from the
857+ // old one has to go.
858+ if key != activeZaiAPIKey {
859+ zaiUsage = nil
860+ zaiError = nil
861+ zaiHistory.removeAll()
862+ }
863+ // Show the trimmed key that was actually stored.
864+ zaiAPIKeyInput = key
865+ activeZaiAPIKey = key
866+ refresh()
867+ }
868+
869+ // Reuse the same "✓ Saved" confirmation — the user sees one per save action,
870+ // regardless of which key it was for.
871+ savedConfirmation = true
872+ savedResetTask?.cancel()
873+ savedResetTask = Task { @MainActor in
874+ try? await Task.sleep(nanoseconds: 2_000_000_000)
875+ guard !Task.isCancelled else { return }
876+ savedConfirmation = false
877+ }
878+ }
879+
501880 // MARK: - Launch at Login
502881
503882 func updateLaunchAtLogin(_ enabled: Bool) {
@@ -517,4 +896,4 @@ final class ViewModel: ObservableObject {
517896 isInitializingLaunchAtLogin = false
518897 }
519898 }
520−}
899+}