@@ -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,11 +237,13 @@ final class ViewModel: ObservableObject {
186237 balanceFormatter.string(from: NSNumber(value: value)) ?? "\(value)"
187238 }
188239
189− /// The text to show in the menu bar: `⚡{balance}` followed by Claude usage
190− /// windows, each prefixed with an emoji so they are distinguishable at a glance:
191− /// 🕐 for the 5-hour window, 📅 for the 7-day window. Windows that are absent or
192− /// at 0% are omitted; with neither, the bolt stands in alone: `⚡…` while the
193− /// first fetch is in flight, `⚡?` 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
@@ -198,23 +251,54 @@ final class ViewModel: ObservableObject {
198251 static func statusBarText(
199252 balance: Int?,
200253 isLoading: Bool,
254+ hyperConfigured: Bool,
201255 claudeFiveHourPercent: Int?,
202− claudeSevenDayPercent: Int?
256+ claudeSevenDayPercent: Int?,
257+ zaiFiveHourPercent: Int?,
258+ zaiWeeklyPercent: Int?,
259+ zaiInPeakHours: Bool
203260 ) -> String {
204− var parts: [String] = []
205− if let balance = balance {
206− parts.append("⚡\(formatBalance(balance))")
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)%")
207275 }
208− if let fiveHour = claudeFiveHourPercent, fiveHour > 0 {
209− parts.append("🕐\(fiveHour)%")
276+ if !claudeWindows.isEmpty {
277+ segments.append("⁕" + claudeWindows.joined(separator: " "))
210278 }
211− if let sevenDay = claudeSevenDayPercent, sevenDay > 0 {
212− parts.append("📅\(sevenDay)%")
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)%")
213287 }
214− if parts.isEmpty {
215− return isLoading ? "⚡…" : "⚡?"
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 ? "…" : ""
216300 }
217− return parts.joined(separator: " · ")
301+ return segments.joined(separator: " · ")
218302 }
219303
220304 /// The text to show in the menu bar for the current state.
@@ -222,11 +306,21 @@ final class ViewModel: ObservableObject {
222306 Self.statusBarText(
223307 balance: balance,
224308 isLoading: isLoading,
309+ hyperConfigured: hyperConfigured,
225310 claudeFiveHourPercent: claudeFiveHourPercent,
226− claudeSevenDayPercent: claudeSevenDayPercent
311+ claudeSevenDayPercent: claudeSevenDayPercent,
312+ zaiFiveHourPercent: zaiFiveHourPercent,
313+ zaiWeeklyPercent: zaiWeeklyPercent,
314+ zaiInPeakHours: Self.zaiInPeakHours
227315 )
228316 }
229317
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+
230324 /// The formatted balance string for display in the popover.
231325 var formattedBalance: String {
232326 guard let balance = balance else { return "?" }
@@ -247,51 +341,88 @@ final class ViewModel: ObservableObject {
247341 return "Updated \(Self.relativeFormatter.localizedString(for: lastUpdated, relativeTo: Date()))"
248342 }
249343
250− // MARK: - History
344+ // MARK: - History (Hyper)
251345
252− /// The last 24 hours of successful fetches, oldest first.
346+ /// The last 24 hours of successful balance fetches, oldest first.
253347 var balanceHistory: [(date: Date, balance: Int)] {
254− history.map { (date: $0.date, balance: $0.balance) }
348+ history.map { (date: $0.date, balance: $0.value) }
255349 }
256350
257351 /// The direction of travel across the most recent handful of observations.
258352 /// `.unknown` until there are at least two points to compare.
259− var balanceTrend: BalanceTrend {
260− guard history.count >= 2 else { return .unknown }
261− 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)
262392 guard let first = recent.first, let last = recent.last else { return .unknown }
263− if last.balance > first.balance { return .increasing }
264− if last.balance < first.balance { return .decreasing }
393+ if last.value > first.value { return .increasing }
394+ if last.value < first.value { return .decreasing }
265395 return .stable
266396 }
267397
268398 /// Appends an observation and drops anything older than 24 hours or beyond the cap.
269− private func recordHistory(balance: Int, at date: Date) {
270− 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))
271401
272402 let cutoff = date.addingTimeInterval(-Self.historyWindow)
273− history.removeAll { $0.date < cutoff }
403+ array.removeAll { $0.date < cutoff }
274404
275− if history.count > Self.maxHistoryEntries {
276− history.removeFirst(history.count - Self.maxHistoryEntries)
405+ if array.count > Self.maxHistoryEntries {
406+ array.removeFirst(array.count - Self.maxHistoryEntries)
277407 }
278408 }
279409
280410 // MARK: - Refresh
281411
282− /// 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.
283413 ///
284− /// The two are independent: either can fail, or not be configured at all, without
285− /// 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.
286416 func refresh() {
287417 refreshTask?.cancel()
288418
289419 // Deliberately the saved key rather than `apiKeyInput`: see `activeAPIKey`.
290420 let key = activeAPIKey
421+ let zaiKey = activeZaiAPIKey
291422 if key.isEmpty {
292423 // Nothing to fetch, and nothing worth keeping: the balance, its history and
293− // any error all belonged to a key that is no longer there. Claude is left
294− // 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.
295426 balance = nil
296427 errorMessage = nil
297428 lastUpdated = nil
@@ -302,22 +433,25 @@ final class ViewModel: ObservableObject {
302433 // Check cancellation before setting isLoading — a previous
303434 // refresh() may have cancelled us and already set isLoading = false.
304435 guard !Task.isCancelled else { return }
305− // Loading state covers both fetches: the popover's loading view depends
306− // 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.
307438 isLoading = true
308439 // Don't clear the errors here — keep showing the last one
309440 // until we have a successful result.
310441
311− // Both requests go out at once; neither waits on the other.
442+ // All three requests go out at once; none waits on the others.
312443 async let balanceOutcome = fetchBalance(key: key)
313444 async let claudeOutcome = fetchClaudeUsage()
445+ async let zaiOutcome = fetchZaiUsage(key: zaiKey)
314446
315447 let balanceResult = await balanceOutcome
316448 let claudeResult = await claudeOutcome
449+ let zaiResult = await zaiOutcome
317450 guard !Task.isCancelled else { return }
318451
319452 applyBalance(balanceResult)
320453 applyClaude(claudeResult)
454+ applyZai(zaiResult)
321455 isLoading = false
322456 }
323457 }
@@ -344,7 +478,7 @@ final class ViewModel: ObservableObject {
344478 errorMessage = nil
345479 let now = Date()
346480 lastUpdated = now
347− recordHistory(balance: newBalance, at: now)
481+ recordMetric(newBalance, into: &history, at: now)
348482
349483 // Low-balance notification: on threshold crossing (≥10 → <10)
350484 // OR on first successful fetch if already below threshold.
@@ -389,12 +523,30 @@ final class ViewModel: ObservableObject {
389523 claudeUsage = nil
390524 claudePlan = nil
391525 claudeError = nil
526+ claudeHistory.removeAll()
392527
393528 case .usage(let report):
529+ // Capture the previous 5-hour % for threshold-crossing notification.
530+ let previousPercent = claudeFiveHourPercent
394531 claudeUsage = report.usage
395532 claudePlan = report.subscriptionType
396533 claudeError = nil
397534
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+
398550 case .failure(let message):
399551 // As with the balance: keep the last good numbers on screen and say what
400552 // went wrong, rather than blanking the section on a transient failure.
@@ -436,6 +588,88 @@ final class ViewModel: ObservableObject {
436588 }
437589 }
438590
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+
439673 // MARK: - Clipboard
440674
441675 /// Copies the current balance to the clipboard as plain digits (no grouping
@@ -456,7 +690,41 @@ final class ViewModel: ObservableObject {
456690 }
457691 }
458692
459− // 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
460728
461729 private func sendLowBalanceNotification(balance: Int) {
462730 // Build the body here, on the main actor. `getNotificationSettings` calls back on
@@ -485,6 +753,29 @@ final class ViewModel: ObservableObject {
485753 }
486754 }
487755
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+
488779 // MARK: - API Key
489780
490781 /// Saves the current `apiKeyInput` to the Keychain and triggers a refresh.
@@ -499,6 +790,7 @@ final class ViewModel: ObservableObject {
499790 }
500791 apiKeyInput = ""
501792 activeAPIKey = ""
793+ hyperConfigured = false
502794 // refresh() with an empty key clears balance, error, history, and
503795 // cancels any in-flight task from the previous key.
504796 refresh()
@@ -522,6 +814,7 @@ final class ViewModel: ObservableObject {
522814 // Show the trimmed key that was actually stored.
523815 apiKeyInput = key
524816 activeAPIKey = key
817+ hyperConfigured = true
525818 refresh()
526819 }
527820
@@ -537,6 +830,53 @@ final class ViewModel: ObservableObject {
537830 }
538831 }
539832
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+
540880 // MARK: - Launch at Login
541881
542882 func updateLaunchAtLogin(_ enabled: Bool) {
@@ -556,4 +896,4 @@ final class ViewModel: ObservableObject {
556896 isInitializingLaunchAtLogin = false
557897 }
558898 }
559−}
899+}