Show opt-in model, context %, and estimated cost next to agent status in the sidebar

Packages/Shared/CmuxAgentChat/Sources/CmuxAgentChat/Usage/AgentModelCatalog.swift

@@ -0,0 +1,126 @@
+import Foundation
+
+/// Resolves model ids found in agent transcripts to a display name, context
+/// window, and published list prices.
+///
+/// The price table is deliberately small and explicit: a model that is not
+/// listed gets no cost estimate instead of a guessed one. Only Anthropic
+/// models are priced; Codex/OpenAI models show model and context only.
+///
+/// ```swift
+/// let info = AgentModelCatalog().info(forModelID: "claude-opus-4-8")
+/// // info?.displayName == "Opus 4.8", info?.contextWindow == 1_000_000
+/// ```
+public struct AgentModelCatalog: Sendable {
+    /// Context window assumed for Claude models not known to support 1M.
+    public static let defaultClaudeContextWindow = 200_000
+    /// Context window for 1M-token models (and `[1m]` model ids).
+    public static let oneMillionContextWindow = 1_000_000
+
+    /// Claude model families (id without the `claude-` prefix and any date
+    /// suffix) that run with a 1M-token context window by default.
+    static let claudeOneMillionFamilies: Set<String> = [
+        "fable-5-1", "fable-5", "mythos-5-1", "mythos-5",
+        "opus-5-5", "opus-5", "opus-4-8", "opus-4-7", "opus-4-6",
+        "sonnet-5", "sonnet-4-6",
+    ]
+
+    /// Anthropic first-party API list prices in USD per million tokens,
+    /// keyed by normalized family. Source: Anthropic model/pricing tables as
+    /// of 2026-06-24 (input, output, cache read; 5-minute and 1-hour cache
+    /// writes are 1.25x and 2x input). Update this table and its date
+    /// together.
+    static let claudePrices: [String: AgentModelPricing] = [
+        "fable-5-1": .anthropic(input: 10, output: 50, cacheRead: 0.25),
+        "mythos-5-1": .anthropic(input: 10, output: 50, cacheRead: 0.25),
+        "fable-5": .anthropic(input: 10, output: 50, cacheRead: 1),
+        "mythos-5": .anthropic(input: 10, output: 50, cacheRead: 1),
+        "opus-5-5": .anthropic(input: 4, output: 20, cacheRead: 0.2),
+        "opus-5": .anthropic(input: 5, output: 25, cacheRead: 0.5),
+        "opus-4-8": .anthropic(input: 5, output: 25, cacheRead: 0.5),
+        "opus-4-7": .anthropic(input: 5, output: 25, cacheRead: 0.5),
+        "opus-4-6": .anthropic(input: 5, output: 25, cacheRead: 0.5),
+        "opus-4-5": .anthropic(input: 5, output: 25, cacheRead: 0.5),
+        "opus-4-1": .anthropic(input: 15, output: 75, cacheRead: 1.5),
+        "opus-4": .anthropic(input: 15, output: 75, cacheRead: 1.5),
+        "sonnet-5": .anthropic(input: 2, output: 10, cacheRead: 0.2),
+        "sonnet-4-6": .anthropic(input: 3, output: 15, cacheRead: 0.3),
+        "sonnet-4-5": .anthropic(input: 3, output: 15, cacheRead: 0.3),
+        "sonnet-4": .anthropic(input: 3, output: 15, cacheRead: 0.3),
+        "haiku-4-5": .anthropic(input: 1, output: 5, cacheRead: 0.1),
+    ]
+
+    /// Creates a catalog over the built-in tables.
+    public init() {}
+
+    /// Describes a model id as written in a transcript.
+    ///
+    /// Claude ids may carry a provider prefix (`us.anthropic.`), a date
+    /// suffix (`-20251001`), a Vertex version (`@20251001`), a Bedrock
+    /// version (`-v1:0`), or a `[1m]` suffix; all are normalized before
+    /// lookup. `[1m]` forces a 1M context window.
+    ///
+    /// - Parameters:
+    ///   - modelID: The raw model id.
+    ///   - reportedContextWindow: A context window the transcript itself
+    ///     reported (Codex `model_context_window`); wins over the table.
+    /// - Returns: The model description, or `nil` for an empty id.
+    public func info(forModelID modelID: String, reportedContextWindow: Int? = nil) -> AgentModelInfo? {
+        let trimmed = modelID.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        let lowered = trimmed.lowercased()
+        if let family = Self.claudeFamily(fromModelID: lowered) {
+            let forcesOneMillion = lowered.contains("[1m]")
+            let tableWindow = forcesOneMillion || Self.claudeOneMillionFamilies.contains(family)
+                ? Self.oneMillionContextWindow
+                : Self.defaultClaudeContextWindow
+            return AgentModelInfo(
+                displayName: Self.claudeDisplayName(family: family) ?? trimmed,
+                contextWindow: reportedContextWindow ?? tableWindow,
+                pricing: Self.claudePrices[family]
+            )
+        }
+        return AgentModelInfo(displayName: trimmed, contextWindow: reportedContextWindow, pricing: nil)
+    }
+
+    /// Extracts the normalized Claude family (`opus-4-8`) from an id such as
+    /// `us.anthropic.claude-opus-4-8-20260101-v1:0[1m]` or
+    /// `claude-haiku-4-5@20251001`, or `nil` when the id is not a Claude id.
+    static func claudeFamily(fromModelID lowered: String) -> String? {
+        guard let range = lowered.range(of: "claude-") else { return nil }
+        var rest = String(lowered[range.upperBound...])
+        if let cut = rest.firstIndex(where: { $0 == "[" || $0 == "@" || $0 == ":" }) {
+            rest = String(rest[..<cut])
+        }
+        var parts: [String] = []
+        for part in rest.split(separator: "-") {
+            // A date stamp (8 digits) or provider version suffix ends the family.
+            if part.count == 8, part.allSatisfy(\.isNumber) { break }
+            if part.hasPrefix("v"), part.dropFirst().first?.isNumber == true { break }
+            parts.append(String(part))
+        }
+        guard !parts.isEmpty else { return nil }
+        return parts.joined(separator: "-")
+    }
+
+    /// `opus-4-8` → `Opus 4.8`, and the legacy order `3-5-sonnet` → `Sonnet
+    /// 3.5`. Current ids put the name first and the version after it; ids up
+    /// to Claude 3.7 put the version first. Both forms are named after the
+    /// first component that starts with a letter, with the numbers on either
+    /// side of it joined by dots. Returns `nil` only when no component starts
+    /// with a letter.
+    static func claudeDisplayName(family: String) -> String? {
+        let parts = family.split(separator: "-")
+        guard let nameIndex = parts.firstIndex(where: { $0.first?.isLetter == true }) else {
+            return nil
+        }
+        let name = parts[nameIndex]
+        let leadingVersion = parts[..<nameIndex]
+        let trailingVersion = parts[parts.index(after: nameIndex)...]
+            .prefix { $0.allSatisfy(\.isNumber) }
+        let version = leadingVersion.isEmpty ? Array(trailingVersion) : Array(leadingVersion)
+        let title = name.prefix(1).uppercased() + name.dropFirst()
+        guard !version.isEmpty else { return title }
+        return title + " " + version.joined(separator: ".")
+    }
+}

Packages/Shared/CmuxAgentChat/Sources/CmuxAgentChat/Usage/AgentModelInfo.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+/// What cmux knows about one model id: a short display name, its context
+/// window, and (when listed) its published prices.
+public struct AgentModelInfo: Sendable, Equatable {
+    /// Short display name, e.g. `Opus 4.8` or `gpt-5-codex`.
+    public let displayName: String
+    /// Context window in tokens, or `nil` when neither the transcript nor
+    /// the built-in table knows it (the context percentage is then omitted).
+    public let contextWindow: Int?
+    /// Published list prices, or `nil` when the model is not in the price
+    /// table (cost is then omitted rather than guessed).
+    public let pricing: AgentModelPricing?
+
+    /// Creates a model description.
+    public init(displayName: String, contextWindow: Int?, pricing: AgentModelPricing?) {
+        self.displayName = displayName
+        self.contextWindow = contextWindow
+        self.pricing = pricing
+    }
+}

Packages/Shared/CmuxAgentChat/Sources/CmuxAgentChat/Usage/AgentModelPricing.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+/// Published per-million-token list prices for one model, in US dollars.
+///
+/// These are public API list prices used only to *estimate* what a session
+/// would cost at pay-as-you-go rates. Not modelled: subscriptions (a Claude
+/// plan is not billed per token), batch and priority tiers, regional and
+/// partner (Bedrock/Vertex/Foundry) pricing, data-residency multipliers,
+/// long-context premiums of older 1M betas, fast mode, and server-tool fees
+/// such as web search. The result is labelled as an estimate wherever shown.
+public struct AgentModelPricing: Sendable, Equatable {
+    /// Base input price per million tokens.
+    public let inputPerMTok: Double
+    /// Output price per million tokens.
+    public let outputPerMTok: Double
+    /// 5-minute cache-write price per million tokens.
+    public let cacheWrite5mPerMTok: Double
+    /// 1-hour cache-write price per million tokens.
+    public let cacheWrite1hPerMTok: Double
+    /// Cache-read price per million tokens.
+    public let cacheReadPerMTok: Double
+
+    /// Creates a price row.
+    public init(
+        inputPerMTok: Double,
+        outputPerMTok: Double,
+        cacheWrite5mPerMTok: Double,
+        cacheWrite1hPerMTok: Double,
+        cacheReadPerMTok: Double
+    ) {
+        self.inputPerMTok = inputPerMTok
+        self.outputPerMTok = outputPerMTok
+        self.cacheWrite5mPerMTok = cacheWrite5mPerMTok
+        self.cacheWrite1hPerMTok = cacheWrite1hPerMTok
+        self.cacheReadPerMTok = cacheReadPerMTok
+    }
+
+    /// Anthropic pricing shape: cache writes cost 1.25x (5m) and 2x (1h)
+    /// the input price; the cache-read price is model specific.
+    static func anthropic(input: Double, output: Double, cacheRead: Double) -> Self {
+        Self(
+            inputPerMTok: input,
+            outputPerMTok: output,
+            cacheWrite5mPerMTok: input * 1.25,
+            cacheWrite1hPerMTok: input * 2,
+            cacheReadPerMTok: cacheRead
+        )
+    }
+
+    /// Estimated cost of `tokens` at these prices, in US dollars.
+    ///
+    /// - Parameter tokens: Token counts split by billing class.
+    /// - Returns: The dollar estimate.
+    public func estimatedCostUSD(for tokens: AgentUsageTokenCounts) -> Double {
+        let dollars = Double(tokens.uncachedInput) * inputPerMTok
+            + Double(tokens.cacheWrite5m) * cacheWrite5mPerMTok
+            + Double(tokens.cacheWrite1h) * cacheWrite1hPerMTok
+            + Double(tokens.cacheRead) * cacheReadPerMTok
+            + Double(tokens.output) * outputPerMTok
+        return dollars / 1_000_000
+    }
+}

Packages/Shared/CmuxAgentChat/Sources/CmuxAgentChat/Usage/AgentUsageCost.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+/// An estimated API cost and whether it is complete.
+public struct AgentUsageCost: Sendable, Equatable {
+    /// Estimated cost in US dollars at published list prices.
+    public let usd: Double
+    /// `true` when some usage could not be priced (unknown model, or a
+    /// transcript line too large to read), so the real figure is higher.
+    public let isLowerBound: Bool
+    /// Whether any usage was actually priced. A cost built only from
+    /// unknown models carries no information and is not displayed.
+    public let hasPricedUsage: Bool
+
+    /// Creates a cost.
+    public init(usd: Double, isLowerBound: Bool, hasPricedUsage: Bool = true) {
+        self.usd = usd
+        self.isLowerBound = isLowerBound
+        self.hasPricedUsage = hasPricedUsage
+    }
+
+    /// This cost when it is worth showing, or `nil` when nothing was priced.
+    public var displayable: Self? {
+        hasPricedUsage ? self : nil
+    }
+
+    /// Adds two estimates; the sum is a lower bound if either part is.
+    public static func + (lhs: Self, rhs: Self) -> Self {
+        Self(
+            usd: lhs.usd + rhs.usd,
+            isLowerBound: lhs.isLowerBound || rhs.isLowerBound,
+            hasPricedUsage: lhs.hasPricedUsage || rhs.hasPricedUsage
+        )
+    }
+
+    /// Adds two optional estimates; `nil` (unknown) is contagious.
+    static func combine(_ lhs: Self?, _ rhs: Self?) -> Self? {
+        guard let lhs, let rhs else { return nil }
+        return lhs + rhs
+    }
+}

Packages/Shared/CmuxAgentChat/Sources/CmuxAgentChat/Usage/AgentUsageFileCursor.swift

@@ -0,0 +1,31 @@
+import Foundation
+
+/// Incremental read position and parse state for one transcript file.
+///
+/// Values are handed between the ``AgentUsageSampler`` actor and the
+/// detached task that reads the file, so everything here is `Sendable`.
+struct AgentUsageFileCursor: Sendable {
+    /// Usage folded from the lines read so far.
+    var accumulator: AgentUsageTranscriptAccumulator
+    /// Bytes consumed from the start of the file.
+    var byteOffset: UInt64 = 0
+    /// Inode of the file when last read (from `fstat` on the open fd).
+    var inode: UInt64?
+    /// Size and modification time (ns) from the last read's `fstat`; when a
+    /// plain `stat` still matches them (and the inode), the file is skipped
+    /// without being opened.
+    var statSize: UInt64 = 0
+    var modificationNanos: Int64 = 0
+    /// The first bytes of the file when last read. A mismatch means the file
+    /// was rewritten in place, even if it is now larger.
+    var head = Data()
+    /// Bytes of an incomplete trailing line, awaiting its newline.
+    var fragment = Data()
+    /// Skip bytes until the next newline (an oversized line, or the partial
+    /// first line of a tail read).
+    var discardingLine = false
+
+    init(source: AgentUsageSource, catalog: AgentModelCatalog) {
+        accumulator = AgentUsageTranscriptAccumulator(source: source, catalog: catalog)
+    }
+}