feat: Add server metrics dashboard and beta update channel

- Server metrics tracking (requests, tokens, TTFT)
- Metrics dashboard in ServerDashboardView
- Beta update channel via Sparkle (opt-in in Settings)
- Swift 6.2 concurrency fix for StreamMetricsTracker

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: taylorarndt

Perspective Server/FoundationModelsService.swift

@@ -379,18 +379,30 @@ nonisolated final class FoundationModelsService: @unchecked Sendable {
         await inferenceSemaphore.acquire()
         defer { Task { await inferenceSemaphore.release() } }
 
+        let inferenceStart = ContinuousClock.now
+
         // Always use tools for file operations - this enables the model to create/edit files
         // even when the client doesn't explicitly request tool support
         #if canImport(FoundationModels)
         if #available(macOS 26.0, iOS 26.0, visionOS 26.0, *) {
             // Use native Foundation Models with built-in file tools
-            return try await handleChatCompletionWithBuiltInTools(request)
+            let result = try await handleChatCompletionWithBuiltInTools(request)
+            let elapsed = ContinuousClock.now - inferenceStart
+            let ttft = Double(elapsed.components.seconds) + Double(elapsed.components.attoseconds) / 1e18
+            let outputLen = result.choices.first?.message.content.count ?? 0
+            await ServerMetrics.shared.recordInference(tokens: max(1, outputLen / 4), timeToFirstToken: ttft)
+            return result
         }
         #endif
 
         // Fallback for older systems: If tools are provided, run the tool-calling orchestration flow.
         if let tools = request.tools, !tools.isEmpty {
-            return try await handleChatCompletionWithTools(request, tools: tools)
+            let result = try await handleChatCompletionWithTools(request, tools: tools)
+            let elapsed = ContinuousClock.now - inferenceStart
+            let ttft = Double(elapsed.components.seconds) + Double(elapsed.components.attoseconds) / 1e18
+            let outputLen = result.choices.first?.message.content.count ?? 0
+            await ServerMetrics.shared.recordInference(tokens: max(1, outputLen / 4), timeToFirstToken: ttft)
+            return result
         }
 
         // Build a context-aware prompt that fits within the model's context by summarizing older content when needed.
@@ -401,6 +413,10 @@ nonisolated final class FoundationModelsService: @unchecked Sendable {
         let output = try await generateText(model: request.model, prompt: prompt, temperature: request.temperature, maxTokens: request.max_tokens)
         logger.log("[chat] outputLen=\(output.count)")
 
+        let elapsed = ContinuousClock.now - inferenceStart
+        let ttft = Double(elapsed.components.seconds) + Double(elapsed.components.attoseconds) / 1e18
+        await ServerMetrics.shared.recordInference(tokens: max(1, output.count / 4), timeToFirstToken: ttft)
+
         let response = ChatCompletionResponse(
             id: "chatcmpl_" + UUID().uuidString.replacingOccurrences(of: "-", with: ""),
             object: "chat.completion",
@@ -436,15 +452,24 @@ nonisolated final class FoundationModelsService: @unchecked Sendable {
 
         let resolvedID = sessionID ?? UUID().uuidString
 
+        // Metrics: track TTFT and token count via a Sendable tracker
+        let tracker = StreamMetricsTracker()
+
+        let wrappedEmit: @Sendable (String) async -> Void = { delta in
+            tracker.recordDelta(delta)
+            await emit(delta)
+        }
+
         #if canImport(FoundationModels)
         if #available(macOS 26.0, iOS 26.0, visionOS 26.0, *) {
             try await streamWithFoundationModels(
                 messages: messages,
                 model: model,
                 temperature: temperature,
                 sessionID: resolvedID,
-                emit: emit
+                emit: wrappedEmit
             )
+            await ServerMetrics.shared.recordInference(tokens: tracker.tokenCount, timeToFirstToken: tracker.ttft)
             return resolvedID
         }
         #endif
@@ -459,8 +484,9 @@ nonisolated final class FoundationModelsService: @unchecked Sendable {
             temperature: temperature, maxTokens: nil
         )
         for chunk in StreamChunker.chunk(text: output, size: 16) {
-            await emit(chunk)
+            await wrappedEmit(chunk)
         }
+        await ServerMetrics.shared.recordInference(tokens: tracker.tokenCount, timeToFirstToken: tracker.ttft)
         return resolvedID
     }
 

Perspective Server/LocalHTTPServer.swift

@@ -100,6 +100,8 @@ actor LocalHTTPServer {
         let _ = await self.incrementActiveRequests()
         defer { Task { let _ = await self.decrementActiveRequests() } }
 
+        await ServerMetrics.shared.recordRequest()
+
         // CORS preflight support
         if request.method == "OPTIONS" {
             return .normal(HTTPResponse(status: 204, headers: [
@@ -156,6 +158,7 @@ actor LocalHTTPServer {
             let serverPort = await self.port
             let activeReqs = await self.getActiveRequestCount()
             let inferenceStats = await FoundationModelsService.shared.inferenceSemaphore.stats
+            let metricsSnap = await ServerMetrics.shared.snapshot
             let obj: [String: Any] = [
                 "status": "ok",
                 "running": serverIsRunning,
@@ -167,7 +170,15 @@ actor LocalHTTPServer {
                     "max_concurrent": inferenceStats.maxConcurrent,
                     "total_completed": inferenceStats.totalCompleted,
                     "total_queued": inferenceStats.totalQueued,
-                ]
+                ],
+                "metrics": [
+                    "total_requests": metricsSnap.totalRequests,
+                    "total_inference_requests": metricsSnap.totalInferenceRequests,
+                    "total_tokens": metricsSnap.totalTokens,
+                    "requests_last_5min": metricsSnap.requestsLast5Min,
+                    "avg_ttft_seconds": metricsSnap.averageTTFT ?? -1,
+                    "last_ttft_seconds": metricsSnap.lastTTFT ?? -1,
+                ] as [String: Any]
             ]
             let data = (try? JSONSerialization.data(withJSONObject: obj, options: [])) ?? Data()
             let resp = HTTPResponse(status: 200, headers: [

Perspective Server/Perspective_ServerApp.swift

@@ -12,12 +12,17 @@ import AppKit
 import Sparkle
 
 @MainActor
-class AppDelegate: NSObject, NSApplicationDelegate, SPUStandardUserDriverDelegate {
+class AppDelegate: NSObject, NSApplicationDelegate, SPUUpdaterDelegate, SPUStandardUserDriverDelegate {
     private(set) var updaterController: SPUStandardUpdaterController!
 
     override init() {
         super.init()
-        self.updaterController = SPUStandardUpdaterController(startingUpdater: true, updaterDelegate: nil, userDriverDelegate: self)
+        self.updaterController = SPUStandardUpdaterController(startingUpdater: true, updaterDelegate: self, userDriverDelegate: self)
+    }
+
+    nonisolated func allowedChannels(for updater: SPUUpdater) -> Set<String> {
+        let betaEnabled = UserDefaults.standard.bool(forKey: "enableBetaUpdates")
+        return betaEnabled ? ["beta"] : []
     }
 
     var supportsGentleScheduledUpdateReminders: Bool { true }

Perspective Server/ServerApp.swift

@@ -38,6 +38,7 @@ final class ServerController: ObservableObject {
     func start() {
         errorMessage = nil
         Task {
+            await ServerMetrics.shared.reset()
             await LocalHTTPServer.shared.setPort(port)
             await LocalHTTPServer.shared.start()
             // Wait a moment for the listener to become ready, then sync state

Perspective Server/ServerDashboardView.swift

@@ -18,6 +18,12 @@ struct ServerDashboardView: View {
     @State private var isTesting: Bool = false
     @State private var logMessages: [LogMessage] = []
     @State private var autoStart: Bool = true
+    @State private var metrics: MetricsSnapshot = MetricsSnapshot(
+        totalRequests: 0, totalInferenceRequests: 0,
+        totalTokens: 0, requestsLast5Min: 0,
+        averageTTFT: nil, lastTTFT: nil
+    )
+    @State private var metricsTimer: Timer? = nil
 
     // Native system colors
     private let successColor = Color.green
@@ -32,7 +38,12 @@ struct ServerDashboardView: View {
 
                     // Main Status Card
                     mainStatusCard
-                    
+
+                    // Server Stats Card
+                    if serverController.isRunning {
+                        serverStatsCard
+                    }
+
                     // Server Controls Card
                     serverControlsCard
 
@@ -67,6 +78,16 @@ struct ServerDashboardView: View {
         .frame(minWidth: 550, minHeight: 700)
         .onAppear {
             syncServerState()
+            refreshMetrics()
+            metricsTimer = Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { _ in
+                Task { @MainActor in
+                    await refreshMetrics()
+                }
+            }
+        }
+        .onDisappear {
+            metricsTimer?.invalidate()
+            metricsTimer = nil
         }
         .animation(.easeInOut(duration: 0.25), value: showCopiedToast)
     }
@@ -747,8 +768,120 @@ struct ServerDashboardView: View {
         )
     }
 
+    // MARK: - Server Stats Card
+
+    private var serverStatsCard: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            HStack {
+                Label("Server Stats", systemImage: "chart.bar.fill")
+                    .font(.headline)
+                    .foregroundColor(.primary)
+                Spacer()
+
+                Text("Updates every 2s")
+                    .font(.caption2)
+                    .foregroundColor(.secondary)
+            }
+
+            Divider()
+
+            HStack(spacing: 12) {
+                statBox(
+                    title: "Requests",
+                    value: "\(metrics.totalRequests)",
+                    subtitle: "\(metrics.requestsLast5Min) in last 5 min",
+                    icon: "arrow.up.arrow.down"
+                )
+
+                statBox(
+                    title: "Tokens",
+                    value: formatNumber(metrics.totalTokens),
+                    subtitle: "generated",
+                    icon: "textformat.abc"
+                )
+
+                statBox(
+                    title: "Avg TTFT",
+                    value: formatTTFT(metrics.averageTTFT),
+                    subtitle: "time to first token",
+                    icon: "clock"
+                )
+
+                statBox(
+                    title: "Last TTFT",
+                    value: formatTTFT(metrics.lastTTFT),
+                    subtitle: "most recent",
+                    icon: "clock.arrow.circlepath"
+                )
+            }
+        }
+        .padding(20)
+        .background(Color(NSColor.controlBackgroundColor))
+        .cornerRadius(16)
+        .overlay(
+            RoundedRectangle(cornerRadius: 16)
+                .stroke(Color(NSColor.separatorColor), lineWidth: 1)
+        )
+        .accessibilityElement(children: .contain)
+        .accessibilityLabel("Server statistics")
+    }
+
+    private func statBox(title: String, value: String, subtitle: String, icon: String) -> some View {
+        VStack(spacing: 6) {
+            Image(systemName: icon)
+                .font(.title3)
+                .foregroundColor(.accentColor)
+                .accessibilityHidden(true)
+            Text(value)
+                .font(.system(size: 18, weight: .bold, design: .monospaced))
+                .foregroundColor(.primary)
+                .lineLimit(1)
+                .minimumScaleFactor(0.6)
+            Text(title)
+                .font(.caption.weight(.medium))
+                .foregroundColor(.primary)
+            Text(subtitle)
+                .font(.caption2)
+                .foregroundColor(.secondary)
+                .lineLimit(1)
+                .minimumScaleFactor(0.7)
+        }
+        .frame(maxWidth: .infinity)
+        .padding(.vertical, 14)
+        .background(Color(NSColor.textBackgroundColor))
+        .cornerRadius(10)
+        .accessibilityElement(children: .combine)
+        .accessibilityLabel("\(title): \(value), \(subtitle)")
+    }
+
+    private func formatTTFT(_ value: Double?) -> String {
+        guard let v = value, v >= 0 else { return "--" }
+        if v < 1 {
+            return String(format: "%.0fms", v * 1000)
+        } else {
+            return String(format: "%.1fs", v)
+        }
+    }
+
+    private func formatNumber(_ n: Int) -> String {
+        if n >= 1_000_000 {
+            return String(format: "%.1fM", Double(n) / 1_000_000)
+        } else if n >= 1_000 {
+            return String(format: "%.1fK", Double(n) / 1_000)
+        }
+        return "\(n)"
+    }
+
+    @MainActor
+    private func refreshMetrics() {
+        Task {
+            let snap = await ServerMetrics.shared.snapshot
+            metrics = snap
+        }
+    }
+
     // MARK: - Helper Methods
-    
+
     private func syncServerState() {
         Task {
             let running = await LocalHTTPServer.shared.getIsRunning()