@@ -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.usage-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,27 +237,68 @@ final class ViewModel: ObservableObject {
186237 balanceFormatter.string(from: NSNumber(value: value)) ?? "\(value)"
187238 }
188239
189− /// The text to show in the menu bar: `⚡{balance} · {percent}%` with both services,
190− /// and just the half that is there when only one of them is — an unconfigured or
191− /// failing service drops out of the title rather than taking a slot to say nothing.
192− /// With neither, the bolt stands in alone: `⚡…` while the first fetch is in flight,
193− /// `⚡?` once it has come back empty-handed.
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.
245+ ///
246+ /// Example: `⚡42 · ⁕62% 8% · Z12% 3%🔶`
194247 ///
195248 /// Takes its values as parameters rather than reading the properties: `@Published`
196249 /// publishes in `willSet`, so a Combine subscriber that called back into the view
197250 /// model would see the *pre-change* value and render a title one update behind.
198− static func statusBarText(balance: Int?, isLoading: Bool, claudePercent: Int?) -> String {
199− var parts: [String] = []
200− if let balance = balance {
201− parts.append("⚡\(formatBalance(balance))")
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))")
202266 }
203− if let claudePercent = claudePercent {
204− parts.append("\(claudePercent)%")
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)%")
205284 }
206− if parts.isEmpty {
207− return isLoading ? "⚡…" : "⚡?"
285+ if let zaiWeekly = zaiWeeklyPercent {
286+ zaiWindows.append("\(zaiWeekly)%")
208287 }
209− return parts.joined(separator: " · ")
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 ? "…" : ""
300+ }
301+ return segments.joined(separator: " · ")
210302 }
211303
212304 /// The text to show in the menu bar for the current state.
@@ -214,10 +306,21 @@ final class ViewModel: ObservableObject {
214306 Self.statusBarText(
215307 balance: balance,
216308 isLoading: isLoading,
217− claudePercent: claudeStatusBarPercent
309+ hyperConfigured: hyperConfigured,
310+ claudeFiveHourPercent: claudeFiveHourPercent,
311+ claudeSevenDayPercent: claudeSevenDayPercent,
312+ zaiFiveHourPercent: zaiFiveHourPercent,
313+ zaiWeeklyPercent: zaiWeeklyPercent,
314+ zaiInPeakHours: Self.zaiInPeakHours
218315 )
219316 }
220317
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
322+ }
323+
221324 /// The formatted balance string for display in the popover.
222325 var formattedBalance: String {
223326 guard let balance = balance else { return "?" }
@@ -238,51 +341,88 @@ final class ViewModel: ObservableObject {
238341 return "Updated \(Self.relativeFormatter.localizedString(for: lastUpdated, relativeTo: Date()))"
239342 }
240343
241− // MARK: - History
344+ // MARK: - History (Hyper)
242345
243− /// The last 24 hours of successful fetches, oldest first.
346+ /// The last 24 hours of successful balance fetches, oldest first.
244347 var balanceHistory: [(date: Date, balance: Int)] {
245− history.map { (date: $0.date, balance: $0.balance) }
348+ history.map { (date: $0.date, balance: $0.value) }
246349 }
247350
248351 /// The direction of travel across the most recent handful of observations.
249352 /// `.unknown` until there are at least two points to compare.
250− var balanceTrend: BalanceTrend {
251− guard history.count >= 2 else { return .unknown }
252− 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)
253392 guard let first = recent.first, let last = recent.last else { return .unknown }
254− if last.balance > first.balance { return .increasing }
255− if last.balance < first.balance { return .decreasing }
393+ if last.value > first.value { return .increasing }
394+ if last.value < first.value { return .decreasing }
256395 return .stable
257396 }
258397
259398 /// Appends an observation and drops anything older than 24 hours or beyond the cap.
260− private func recordHistory(balance: Int, at date: Date) {
261− 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))
262401
263402 let cutoff = date.addingTimeInterval(-Self.historyWindow)
264− history.removeAll { $0.date < cutoff }
403+ array.removeAll { $0.date < cutoff }
265404
266− if history.count > Self.maxHistoryEntries {
267− history.removeFirst(history.count - Self.maxHistoryEntries)
405+ if array.count > Self.maxHistoryEntries {
406+ array.removeFirst(array.count - Self.maxHistoryEntries)
268407 }
269408 }
270409
271410 // MARK: - Refresh
272411
273− /// 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.
274413 ///
275− /// The two are independent: either can fail, or not be configured at all, without
276− /// 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.
277416 func refresh() {
278417 refreshTask?.cancel()
279418
280419 // Deliberately the saved key rather than `apiKeyInput`: see `activeAPIKey`.
281420 let key = activeAPIKey
421+ let zaiKey = activeZaiAPIKey
282422 if key.isEmpty {
283423 // Nothing to fetch, and nothing worth keeping: the balance, its history and
284− // any error all belonged to a key that is no longer there. Claude is left
285− // 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.
286426 balance = nil
287427 errorMessage = nil
288428 lastUpdated = nil
@@ -293,22 +433,25 @@ final class ViewModel: ObservableObject {
293433 // Check cancellation before setting isLoading — a previous
294434 // refresh() may have cancelled us and already set isLoading = false.
295435 guard !Task.isCancelled else { return }
296− // Loading state covers both fetches: the popover's loading view depends
297− // on it, and Claude usage is fetched even when there's no Hyper key.
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.
298438 isLoading = true
299439 // Don't clear the errors here — keep showing the last one
300440 // until we have a successful result.
301441
302− // Both requests go out at once; neither waits on the other.
442+ // All three requests go out at once; none waits on the others.
303443 async let balanceOutcome = fetchBalance(key: key)
304444 async let claudeOutcome = fetchClaudeUsage()
445+ async let zaiOutcome = fetchZaiUsage(key: zaiKey)
305446
306447 let balanceResult = await balanceOutcome
307448 let claudeResult = await claudeOutcome
449+ let zaiResult = await zaiOutcome
308450 guard !Task.isCancelled else { return }
309451
310452 applyBalance(balanceResult)
311453 applyClaude(claudeResult)
454+ applyZai(zaiResult)
312455 isLoading = false
313456 }
314457 }
@@ -335,7 +478,7 @@ final class ViewModel: ObservableObject {
335478 errorMessage = nil
336479 let now = Date()
337480 lastUpdated = now
338− recordHistory(balance: newBalance, at: now)
481+ recordMetric(newBalance, into: &history, at: now)
339482
340483 // Low-balance notification: on threshold crossing (≥10 → <10)
341484 // OR on first successful fetch if already below threshold.
@@ -380,12 +523,30 @@ final class ViewModel: ObservableObject {
380523 claudeUsage = nil
381524 claudePlan = nil
382525 claudeError = nil
526+ claudeHistory.removeAll()
383527
384528 case .usage(let report):
529+ // Capture the previous 5-hour % for threshold-crossing notification.
530+ let previousPercent = claudeFiveHourPercent
385531 claudeUsage = report.usage
386532 claudePlan = report.subscriptionType
387533 claudeError = nil
388534
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+
389550 case .failure(let message):
390551 // As with the balance: keep the last good numbers on screen and say what
391552 // went wrong, rather than blanking the section on a transient failure.
@@ -393,29 +554,25 @@ final class ViewModel: ObservableObject {
393554 }
394555 }
395556
396− /// The number Claude gets judged by: whichever limit the server itself flags as
397− /// binding, falling back to the 5-hour window when it flags none. `nil` when there
398− /// is no usage to summarize.
399− ///
400− /// Shared by the popover and the menu bar title so the two can never disagree about
401− /// which of the windows is the one that matters.
402− static func claudeHeadline(for usage: ClaudeUsage?) -> (percent: Int, resetsIn: String?)? {
403− guard let usage = usage else { return nil }
404− if let active = usage.activeLimit {
405− return (active.percent, active.resetsInFormatted)
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())
406569 }
407− if let fiveHour = usage.fiveHour {
408− return (Int(fiveHour.utilization.rounded()), fiveHour.resetsInFormatted)
570+ if let opus = claudeUsage?.sevenDayOpus, opus.utilization > 0 {
571+ return Int(opus.utilization.rounded())
409572 }
410573 return nil
411574 }
412575
413− /// The Claude percentage for the menu bar title, or `nil` when Claude Code isn't
414− /// signed in on this machine — in which case the title is Hyper's alone.
415− var claudeStatusBarPercent: Int? {
416− Self.claudeHeadline(for: claudeUsage)?.percent
417− }
418−
419576 /// Display label for the Claude plan, e.g. "Pro" or "Max".
420577 var claudePlanLabel: String? {
421578 guard let plan = claudePlan?.trimmingCharacters(in: .whitespacesAndNewlines),
@@ -431,6 +588,88 @@ final class ViewModel: ObservableObject {
431588 }
432589 }
433590
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+
434673 // MARK: - Clipboard
435674
436675 /// Copies the current balance to the clipboard as plain digits (no grouping
@@ -451,7 +690,41 @@ final class ViewModel: ObservableObject {
451690 }
452691 }
453692
454− // 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
455728
456729 private func sendLowBalanceNotification(balance: Int) {
457730 // Build the body here, on the main actor. `getNotificationSettings` calls back on
@@ -480,6 +753,29 @@ final class ViewModel: ObservableObject {
480753 }
481754 }
482755
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+
483779 // MARK: - API Key
484780
485781 /// Saves the current `apiKeyInput` to the Keychain and triggers a refresh.
@@ -494,6 +790,7 @@ final class ViewModel: ObservableObject {
494790 }
495791 apiKeyInput = ""
496792 activeAPIKey = ""
793+ hyperConfigured = false
497794 // refresh() with an empty key clears balance, error, history, and
498795 // cancels any in-flight task from the previous key.
499796 refresh()
@@ -517,6 +814,7 @@ final class ViewModel: ObservableObject {
517814 // Show the trimmed key that was actually stored.
518815 apiKeyInput = key
519816 activeAPIKey = key
817+ hyperConfigured = true
520818 refresh()
521819 }
522820
@@ -532,6 +830,53 @@ final class ViewModel: ObservableObject {
532830 }
533831 }
534832
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+
535880 // MARK: - Launch at Login
536881
537882 func updateLaunchAtLogin(_ enabled: Bool) {
@@ -551,4 +896,4 @@ final class ViewModel: ObservableObject {
551896 isInitializingLaunchAtLogin = false
552897 }
553898 }
554−}
899+}