Add CLIProxyAPI cost attribution

CHANGELOG.md

@@ -3,6 +3,9 @@
 ## 0.45.3 — Unreleased
 
 ### Fixed
+- Usage & Spend: keep CLIProxyAPI-routed Claude Code sessions in the correct upstream total using request logs
+  and active provider credentials, with sanitized per-request telemetry when available, instead of splitting
+  unchanged usage into separate proxy and unknown-route rows.
 
 ## 0.45.2 — 2026-07-19
 

Sources/CodexBar/CostHistoryChartMenuView.swift

@@ -2,6 +2,15 @@ import Charts
 import CodexBarCore
 import SwiftUI
 
+private func claudeCodeModelProviderText(_ provider: CostUsageAttribution.ModelProvider) -> String {
+    switch provider {
+    case .openAI: "OpenAI model via Claude Code"
+    case .anthropic: "Anthropic model via Claude Code"
+    case .google: "Google model via Claude Code"
+    case .unknown: "Unknown model provider via Claude Code"
+    }
+}
+
 @MainActor
 struct CostHistoryChartMenuView: View {
     typealias DailyEntry = CostUsageDailyReport.Entry
@@ -573,7 +582,7 @@ struct CostHistoryChartMenuView: View {
     }
 
     private static func hasModeSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> Bool {
-        item.standardCostUSD != nil || item.priorityCostUSD != nil
+        item.attribution != nil || item.standardCostUSD != nil || item.priorityCostUSD != nil
     }
 
     private static func detailRowsViewportHeight(rowCount: Int, rowHeight: CGFloat) -> CGFloat {
@@ -839,6 +848,19 @@ struct CostHistoryChartMenuView: View {
 
     private func modelBreakdownModeSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> String? {
         var parts: [String] = []
+        if let attribution = item.attribution {
+            switch attribution.route {
+            case .cliProxyAPI:
+                let route = if let upstream = attribution.upstream {
+                    "\(upstream.displayName) · CLIProxyAPI via Claude Code"
+                } else {
+                    "CLIProxyAPI via Claude Code"
+                }
+                parts.append(route)
+            case .unknown:
+                parts.append(claudeCodeModelProviderText(attribution.modelProvider))
+            }
+        }
         if let standardCost = item.standardCostUSD {
             var standardPart = "Std \(self.costString(standardCost))"
             if let standardTokens = item.standardTokens {
@@ -897,6 +919,7 @@ extension CostHistoryChartMenuView {
 
     struct VisibleModelBreakdownFingerprint: Equatable {
         let modelName: String
+        let attribution: CostUsageAttribution?
         let costBitPattern: UInt64?
         let totalTokens: Int?
         let standardCostBitPattern: UInt64?
@@ -976,6 +999,7 @@ extension CostHistoryChartMenuView {
                     models: session.modelBreakdowns.map { item in
                         VisibleModelBreakdownFingerprint(
                             modelName: item.modelName,
+                            attribution: item.attribution,
                             costBitPattern: item.costUSD.map(\.bitPattern),
                             totalTokens: item.totalTokens,
                             standardCostBitPattern: item.standardCostUSD.map(\.bitPattern),
@@ -995,6 +1019,7 @@ extension CostHistoryChartMenuView {
             modelBreakdowns: self.orderedBreakdownItems(entry.modelBreakdowns ?? []).map { item in
                 VisibleModelBreakdownFingerprint(
                     modelName: item.modelName,
+                    attribution: item.attribution,
                     costBitPattern: item.costUSD.map(\.bitPattern),
                     totalTokens: item.totalTokens,
                     standardCostBitPattern: item.standardCostUSD.map(\.bitPattern),

Sources/CodexBar/PreferencesSpendDashboardPane.swift

@@ -27,6 +27,28 @@ func spendDashboardCoverageText(covered: Int, requested: Int) -> String {
     "\(L("Coverage")): \(codexBarLocalizedInteger(covered)) / \(codexBarLocalizedInteger(requested))"
 }
 
+func spendDashboardModelSourceText(
+    providerName: String,
+    attribution: CostUsageAttribution?) -> String
+{
+    guard let attribution else { return providerName }
+    switch attribution.route {
+    case .cliProxyAPI:
+        if let upstream = attribution.upstream {
+            return "\(upstream.displayName) · CLIProxyAPI via Claude Code"
+        }
+        return "CLIProxyAPI via Claude Code"
+    case .unknown:
+        let modelProvider = switch attribution.modelProvider {
+        case .openAI: "OpenAI model"
+        case .anthropic: "Anthropic model"
+        case .google: "Google model"
+        case .unknown: "Unknown model provider"
+        }
+        return "\(providerName) · \(modelProvider) via Claude Code"
+    }
+}
+
 enum SpendDashboardModelHistoryPresentation: Equatable {
     case unavailable
     case empty
@@ -48,6 +70,11 @@ struct SpendDashboardPane: View {
     @Bindable var settings: SettingsStore
     @Bindable var store: UsageStore
     @State private var controller: SpendDashboardController
+    @State private var cliProxyAPIBaseURL = CLIProxyAPIConnectionSettings.defaultBaseURL
+    @State private var cliProxyAPIManagementKey = ""
+    @State private var cliProxyAPIHasSavedConfiguration = false
+    @State private var cliProxyAPIStatus: String?
+    @State private var cliProxyAPIIsSaving = false
 
     init(settings: SettingsStore, store: UsageStore) {
         self.settings = settings
@@ -62,6 +89,7 @@ struct SpendDashboardPane: View {
             VStack(alignment: .leading, spacing: 18) {
                 self.header
                 self.content
+                self.cliProxyAPISetup
                 self.provenance
                 self.shareAction
             }
@@ -71,6 +99,7 @@ struct SpendDashboardPane: View {
         .onAppear {
             self.controller.refreshDateWindow()
             self.controller.update(configuration: self.configuration)
+            self.loadCLIProxyAPIConfiguration()
         }
         .onChange(of: self.configuration) { _, configuration in
             self.controller.update(configuration: configuration)
@@ -173,6 +202,132 @@ struct SpendDashboardPane: View {
         }
     }
 
+    private var cliProxyAPISetup: some View {
+        SpendDashboardPanel {
+            VStack(alignment: .leading, spacing: 12) {
+                HStack {
+                    Label("CLIProxyAPI attribution", systemImage: "point.3.connected.trianglepath.dotted")
+                        .font(.headline)
+                    Spacer()
+                    if self.cliProxyAPIHasSavedConfiguration {
+                        Label("Configured", systemImage: "checkmark.circle.fill")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                }
+
+                Text(
+                    "Connect CLIProxyAPI’s management usage queue to identify the exact upstream provider " +
+                        "and whether it used OAuth or an API key. Enter the same plaintext " +
+                        "remote-management secret key configured in CLIProxyAPI.")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+
+                Grid(alignment: .leading, horizontalSpacing: 12, verticalSpacing: 10) {
+                    GridRow {
+                        Text("Server URL")
+                            .foregroundStyle(.secondary)
+                        TextField(
+                            CLIProxyAPIConnectionSettings.defaultBaseURL,
+                            text: self.$cliProxyAPIBaseURL)
+                            .textFieldStyle(.roundedBorder)
+                    }
+                    GridRow {
+                        Text("Management key")
+                            .foregroundStyle(.secondary)
+                        SecureField(
+                            self.cliProxyAPIHasSavedConfiguration ? "Saved — enter to replace" : "Required",
+                            text: self.$cliProxyAPIManagementKey)
+                            .textFieldStyle(.roundedBorder)
+                    }
+                }
+
+                HStack(spacing: 8) {
+                    Button(self.cliProxyAPIHasSavedConfiguration ? "Save & test" : "Connect & test") {
+                        Task {
+                            await self.saveAndTestCLIProxyAPIConfiguration()
+                        }
+                    }
+                    .disabled(self.cliProxyAPIIsSaving)
+
+                    if self.cliProxyAPIHasSavedConfiguration {
+                        Button("Remove", role: .destructive) {
+                            self.removeCLIProxyAPIConfiguration()
+                        }
+                        .disabled(self.cliProxyAPIIsSaving)
+                    }
+
+                    if self.cliProxyAPIIsSaving {
+                        ProgressView()
+                            .controlSize(.small)
+                    }
+                    if let cliProxyAPIStatus {
+                        Text(cliProxyAPIStatus)
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                    Spacer()
+                }
+
+                Text(
+                    "Reading the queue removes the returned records from CLIProxyAPI. CodexBar stores a " +
+                        "sanitized local copy for cost attribution and does not retain source, account, " +
+                        "API-key, response-header, or failure-body fields.")
+                    .font(.caption2)
+                    .foregroundStyle(.tertiary)
+            }
+        }
+    }
+
+    private func loadCLIProxyAPIConfiguration() {
+        guard let configuration = CLIProxyAPIConnectionSettingsStore.load() else { return }
+        self.cliProxyAPIBaseURL = configuration.baseURL
+        self.cliProxyAPIHasSavedConfiguration = true
+    }
+
+    private func saveAndTestCLIProxyAPIConfiguration() async {
+        self.cliProxyAPIIsSaving = true
+        defer { self.cliProxyAPIIsSaving = false }
+
+        let existingKey = CLIProxyAPIConnectionSettingsStore.load()?.managementKey ?? ""
+        let enteredKey = self.cliProxyAPIManagementKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        let configuration = CLIProxyAPIConnectionSettings(
+            baseURL: self.cliProxyAPIBaseURL,
+            managementKey: enteredKey.isEmpty ? existingKey : enteredKey)
+        guard configuration.isConfigured else {
+            self.cliProxyAPIStatus = "Enter a valid URL and management key."
+            return
+        }
+        guard CLIProxyAPIConnectionSettingsStore.save(configuration) else {
+            self.cliProxyAPIStatus = "Could not save the management key."
+            return
+        }
+
+        self.cliProxyAPIManagementKey = ""
+        self.cliProxyAPIHasSavedConfiguration = true
+        switch await self.store.collectCLIProxyAPIUsageNow() {
+        case .notConfigured:
+            self.cliProxyAPIStatus = "Configuration was not available."
+        case let .collected(count):
+            self.cliProxyAPIStatus = count == 0
+                ? "Connected. No queued records."
+                : "Connected. Imported \(count) records."
+            self.controller.refresh()
+        case let .failed(message):
+            self.cliProxyAPIStatus = "Saved, but test failed: \(message)"
+        }
+    }
+
+    private func removeCLIProxyAPIConfiguration() {
+        guard CLIProxyAPIConnectionSettingsStore.clear() else {
+            self.cliProxyAPIStatus = "Could not remove the saved configuration."
+            return
+        }
+        self.cliProxyAPIManagementKey = ""
+        self.cliProxyAPIHasSavedConfiguration = false
+        self.cliProxyAPIStatus = "Configuration removed."
+    }
+
     private var shareAction: some View {
         HStack {
             Spacer()
@@ -366,7 +521,11 @@ private struct SpendModelPanel: View {
                             SpendProviderIcon(provider: row.provider)
                             VStack(alignment: .leading, spacing: 2) {
                                 Text(row.modelName).lineLimit(1)
-                                Text(row.providerName).font(.caption).foregroundStyle(.secondary)
+                                Text(spendDashboardModelSourceText(
+                                    providerName: row.providerName,
+                                    attribution: row.attribution))
+                                    .font(.caption)
+                                    .foregroundStyle(.secondary)
                             }
                             Spacer()
                             Text(row.totalCost.map {

Sources/CodexBar/SpendDashboardController.swift

@@ -394,6 +394,16 @@ enum SpendDashboardSource {
             encoder.append(entry.modelBreakdowns?.count)
             for breakdown in entry.modelBreakdowns ?? [] {
                 encoder.append(breakdown.modelName)
+                encoder.append(breakdown.attribution?.client.rawValue ?? "")
+                encoder.append(breakdown.attribution?.route.rawValue ?? "")
+                encoder.append(breakdown.attribution?.modelProvider.rawValue ?? "")
+                encoder.append(breakdown.attribution?.upstream?.provider ?? "")
+                encoder.append(breakdown.attribution?.upstream?.authType.rawValue ?? "")
+                encoder.append(breakdown.attribution?.upstream?.model ?? "")
+                encoder.append(breakdown.attribution?.upstream?.executorType ?? "")
+                for evidence in breakdown.attribution?.evidence ?? [] {
+                    encoder.append(evidence.rawValue)
+                }
                 encoder.append(breakdown.totalTokens)
                 encoder.append(breakdown.requestCount)
                 encoder.append(breakdown.costUSD)

Sources/CodexBar/SpendDashboardModel.swift

@@ -35,15 +35,43 @@ struct SpendDashboardModel: Equatable, Sendable {
     }
 
     struct ModelRow: Identifiable, Equatable, Sendable {
+        struct ID: Hashable, Sendable {
+            let provider: UsageProvider
+            let modelName: String
+            let attribution: CostUsageAttribution?
+        }
+
         let rank: Int
         let provider: UsageProvider
         let providerName: String
         let modelName: String
         let totalTokens: Int?
         let totalCost: Double?
+        let attribution: CostUsageAttribution?
 
-        var id: String {
-            "\(self.provider.rawValue):\(self.modelName)"
+        init(
+            rank: Int,
+            provider: UsageProvider,
+            providerName: String,
+            modelName: String,
+            totalTokens: Int?,
+            totalCost: Double?,
+            attribution: CostUsageAttribution? = nil)
+        {
+            self.rank = rank
+            self.provider = provider
+            self.providerName = providerName
+            self.modelName = modelName
+            self.totalTokens = totalTokens
+            self.totalCost = totalCost
+            self.attribution = attribution
+        }
+
+        var id: ID {
+            ID(
+                provider: self.provider,
+                modelName: self.modelName,
+                attribution: self.attribution)
         }
     }
 
@@ -128,6 +156,7 @@ struct SpendDashboardModel: Equatable, Sendable {
     private struct ModelKey: Hashable {
         let provider: UsageProvider
         let modelName: String
+        let attribution: CostUsageAttribution?
     }
 
     private struct ModelAccumulator {
@@ -285,7 +314,10 @@ struct SpendDashboardModel: Equatable, Sendable {
                 for breakdown in breakdowns {
                     let name = breakdown.modelName.trimmingCharacters(in: .whitespacesAndNewlines)
                     guard !name.isEmpty else { continue }
-                    let key = ModelKey(provider: input.provider, modelName: name)
+                    let key = ModelKey(
+                        provider: input.provider,
+                        modelName: name,
+                        attribution: breakdown.attribution)
                     var aggregate = aggregates[key] ?? ModelAccumulator(
                         providerName: input.modelProviderName,
                         tokens: 0,
@@ -324,7 +356,8 @@ struct SpendDashboardModel: Equatable, Sendable {
                 providerName: value.providerName,
                 modelName: key.modelName,
                 totalTokens: value.sawTokens && !value.invalidTokens && !value.overflowedTokens ? value.tokens : nil,
-                totalCost: value.sawCost && !value.invalidCost && !value.overflowedCost ? value.cost : nil)
+                totalCost: value.sawCost && !value.invalidCost && !value.overflowedCost ? value.cost : nil,
+                attribution: key.attribution)
         }
         .sorted { lhs, rhs in
             switch (lhs.totalCost, rhs.totalCost) {
@@ -346,7 +379,8 @@ struct SpendDashboardModel: Equatable, Sendable {
                 providerName: row.providerName,
                 modelName: row.modelName,
                 totalTokens: row.totalTokens,
-                totalCost: row.totalCost)
+                totalCost: row.totalCost,
+                attribution: row.attribution)
         }
         return ModelSummary(rows: rows, completeness: completeness)
     }