@brimveyn/aimux 1.7.4 → 1.8.0

package/src/index.tsx

@@ -52,7 +52,7 @@ if (command === 'terminal-manager') {
 
 if (command === '--help' || command === '-h') {
   process.stdout.write(
-    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                           Start aimux\n  aimux update                    Update to latest version\n  aimux doctor                    Diagnose setup issues\n  aimux restart-daemon            Restart IPC daemon\n  aimux restart-terminal-manager  Restart terminal-manager (kills live sessions)\n\n'
+    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                           Start aimux\n  aimux update                    Update to latest version\n  aimux doctor                    Diagnose setup issues\n  aimux restart-daemon            Restart IPC daemon\n  aimux restart-terminal-manager  Restart terminal-manager (kills live workspaces)\n\n'
   )
   process.exit(0)
 }

package/src/input/keymap/help-entries.ts

@@ -14,10 +14,10 @@ export const HELP_MODE_LABELS: { modeId: ModeId; label: string }[] = [
   { label: 'Git commit', modeId: 'modal.git-commit' },
   { label: 'New tab', modeId: 'modal.new-tab.command-edit' },
   { label: 'New tab — command', modeId: 'modal.new-tab.command-edit' },
-  { label: 'Session picker', modeId: 'modal.session-picker.filtering' },
-  { label: 'Session picker — filter', modeId: 'modal.session-picker.filtering' },
-  { label: 'Session name', modeId: 'modal.session-name' },
-  { label: 'Create session', modeId: 'modal.create-session' },
+  { label: 'Workspace picker', modeId: 'modal.session-picker.filtering' },
+  { label: 'Workspace picker — filter', modeId: 'modal.session-picker.filtering' },
+  { label: 'Workspace name', modeId: 'modal.session-name' },
+  { label: 'Create workspace', modeId: 'modal.create-session' },
   { label: 'Rename tab', modeId: 'modal.rename-tab' },
   { label: 'Snippet picker', modeId: 'modal.snippet-picker.filtering' },
   { label: 'Snippet picker — filter', modeId: 'modal.snippet-picker.filtering' },

package/src/input/modes/bridge.ts

@@ -43,6 +43,9 @@ export function deriveModeId(state: AppState): ModeId {
     if (state.modal.type === 'new-tab' && state.modal.editingCommand !== null) {
       return 'modal.new-tab.editing-command'
     }
+    if (state.modal.type === 'git-commit' && state.modal.stage === 'confirm') {
+      return 'modal.git-commit.confirm'
+    }
     const modalType = state.modal.type
     const commandEditMode = modalType ? COMMAND_EDIT_MODE_IDS[modalType] : undefined
     if (commandEditMode) {
@@ -53,6 +56,9 @@ export function deriveModeId(state: AppState): ModeId {
   }
 
   if (state.focusMode === 'modal') {
+    if (state.modal.type === 'git-commit' && state.modal.stage === 'generating') {
+      return 'modal.git-commit.generating'
+    }
     const modalType = state.modal.type
     const modalMode = modalType ? MODAL_MODE_IDS[modalType] : undefined
     if (modalMode) {

package/src/input/modes/transitions.ts

@@ -3,7 +3,9 @@ import type { ModeId } from './types'
 const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'git-mode': ['navigation', 'modal.git-commit'],
   'modal.create-session': ['navigation', 'modal.session-picker.filtering'],
-  'modal.git-commit': ['git-mode'],
+  'modal.git-commit': ['git-mode', 'modal.git-commit.confirm', 'modal.git-commit.generating'],
+  'modal.git-commit.confirm': ['modal.git-commit', 'git-mode'],
+  'modal.git-commit.generating': ['modal.git-commit', 'modal.git-commit.confirm', 'git-mode'],
   'modal.help.filtering': ['navigation'],
   'modal.new-tab.command-edit': ['navigation', 'modal.new-tab.editing-command'],
   'modal.new-tab.editing-command': ['navigation', 'modal.new-tab.command-edit'],

package/src/input/modes/types.ts

@@ -18,6 +18,8 @@ export type ModeId =
   | 'modal.help.filtering'
   | 'modal.split-picker'
   | 'modal.git-commit'
+  | 'modal.git-commit.confirm'
+  | 'modal.git-commit.generating'
   | 'modal.update-available'
 
 export type SideEffect =
@@ -55,6 +57,8 @@ export type SideEffect =
   | { type: 'git-restore'; path: string }
   | { type: 'git-rm'; path: string }
   | { type: 'git-commit'; title: string; body: string }
+  | { type: 'git-commit-auto'; title: string; body: string }
+  | { type: 'generate-auto-commit-now'; sessionId: string }
   | { type: 'git-push' }
   | { type: 'confirm-update-selection' }
   | { type: 'switch-session-by-index'; index: number }

package/src/ipc/manager-protocol.ts

@@ -14,8 +14,8 @@ import {
   negotiateProtocolVersion,
 } from './protocol'
 
-export const MANAGER_PROTOCOL_MIN_VERSION = 2
-export const MANAGER_PROTOCOL_VERSION = 2
+export const MANAGER_PROTOCOL_MIN_VERSION = 3
+export const MANAGER_PROTOCOL_VERSION = 3
 
 export interface ManagerHelloRequest {
   minVersion: number

package/src/ipc/protocol.ts

@@ -10,14 +10,8 @@ import type {
 
 import { isWorkspaceSnapshotV1 } from '../state/validation'
 
-// v4 widens sessionStatus from a single status enum to independent
-// {working, waiting} flags so a chip can show both at once.
-// v5 folds initial tab activities and session statuses into attachResult so
-// the client applies them atomically with tab creation — previously they
-// arrived as separate events and could lose to the unknown-tab no-op in
-// the reducer.
-export const IPC_PROTOCOL_MIN_VERSION = 6
-export const IPC_PROTOCOL_VERSION = 6
+export const IPC_PROTOCOL_MIN_VERSION = 7
+export const IPC_PROTOCOL_VERSION = 7
 
 export interface ProtocolHelloRequest {
   minVersion: number

package/src/pty/assistant-status-detector.ts

@@ -85,10 +85,10 @@ export class AssistantStatusDetector {
 }
 
 function extractTailText(viewport: TerminalSnapshot, lineCount: number): string {
+  const lines = viewport.tailLines ?? viewport.lines
   // Full-screen TUIs (claude, opencode) paint in the alternate buffer and
   // often leave the last rows blank, putting their status bar higher up.
   // Skip trailing blank rows before taking the last `lineCount`.
-  const lines = viewport.lines
   let end = lines.length
   while (end > 0) {
     const line = lines[end - 1]

package/src/pty/terminal-snapshot.ts

@@ -4,6 +4,8 @@ import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/type
 
 import { getCurrentTheme } from '../ui/theme'
 
+const SNAPSHOT_TAIL_LINE_COUNT = 10
+
 const ANSI_PALETTE = [
   '#000000',
   '#cd0000',
@@ -142,9 +144,11 @@ function buildLine(
 export function snapshotTerminal(terminal: Terminal, cursorVisible = true): TerminalSnapshot {
   const buffer = terminal.buffer.active
   const startLine = buffer.viewportY
+  const tailStartLine = Math.max(0, buffer.baseY + terminal.rows - SNAPSHOT_TAIL_LINE_COUNT)
   const cursorRow = buffer.cursorY
   const cursorColumn = Math.min(buffer.cursorX, Math.max(terminal.cols - 1, 0))
   const lines: TerminalLine[] = []
+  const tailLines: TerminalLine[] = []
 
   for (let row = 0; row < terminal.rows; row += 1) {
     lines.push(
@@ -152,10 +156,27 @@ export function snapshotTerminal(terminal: Terminal, cursorVisible = true): Term
     )
   }
 
+  for (
+    let lineIndex = tailStartLine;
+    lineIndex <= buffer.baseY + terminal.rows - 1;
+    lineIndex += 1
+  ) {
+    const relativeCursorRow = lineIndex - buffer.baseY
+    tailLines.push(
+      buildLine(
+        terminal,
+        lineIndex,
+        relativeCursorRow === cursorRow ? cursorColumn : null,
+        cursorVisible
+      )
+    )
+  }
+
   return {
     baseY: buffer.baseY,
     cursorVisible,
     lines,
+    tailLines,
     viewportY: buffer.viewportY,
   }
 }
@@ -195,6 +216,13 @@ export function areTerminalSnapshotsEqual(
     return false
   }
 
+  const leftTailLines = left.tailLines ?? []
+  const rightTailLines = right.tailLines ?? []
+
+  if (leftTailLines.length !== rightTailLines.length) {
+    return false
+  }
+
   if (
     left.viewportY !== right.viewportY ||
     left.baseY !== right.baseY ||
@@ -203,8 +231,14 @@ export function areTerminalSnapshotsEqual(
     return false
   }
 
-  return left.lines.every((line, index) => {
-    const other = right.lines[index]
-    return other ? areLinesEqual(line, other) : false
-  })
+  return (
+    left.lines.every((line, index) => {
+      const other = right.lines[index]
+      return other ? areLinesEqual(line, other) : false
+    }) &&
+    leftTailLines.every((line, index) => {
+      const other = rightTailLines[index]
+      return other ? areLinesEqual(line, other) : false
+    })
+  )
 }

package/src/services/ai-usage/adapters/claude.ts

@@ -0,0 +1,139 @@
+import type { AIUsageToolConfig } from '@brimveyn/aimux-config'
+
+import type { UsageSnapshot } from '../types'
+
+import { runCli } from '../spawn'
+
+interface ClaudeOAuthCreds {
+  accessToken: string
+  expiresAt?: number
+}
+
+interface ClaudeKeychainPayload {
+  claudeAiOauth?: {
+    accessToken?: string
+    expiresAt?: number
+    refreshToken?: string
+  }
+}
+
+interface UsageWindow {
+  utilization?: number
+  resets_at?: string
+}
+
+interface ClaudeUsageResponse {
+  five_hour?: UsageWindow
+  seven_day?: UsageWindow
+  seven_day_sonnet?: UsageWindow
+  seven_day_opus?: UsageWindow
+  extra_usage?: UsageWindow & { spent_usd?: number; limit_usd?: number }
+}
+
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage'
+const OAUTH_BETA_HEADER = 'oauth-2025-04-20'
+const FETCH_TIMEOUT_MS = 15_000
+
+let cachedCreds: ClaudeOAuthCreds | null = null
+const CREDS_EXPIRY_BUFFER_MS = 60_000
+
+async function readClaudeCreds(): Promise<ClaudeOAuthCreds> {
+  const now = Date.now()
+  if (
+    cachedCreds &&
+    typeof cachedCreds.expiresAt === 'number' &&
+    cachedCreds.expiresAt - CREDS_EXPIRY_BUFFER_MS > now
+  ) {
+    return cachedCreds
+  }
+
+  if (process.platform !== 'darwin') {
+    throw new Error('claude usage requires macOS keychain (darwin only)')
+  }
+  const result = await runCli('security', [
+    'find-generic-password',
+    '-s',
+    'Claude Code-credentials',
+    '-w',
+  ])
+  if (!result.ok) {
+    throw new Error(`keychain read failed — run \`claude\` to sign in`)
+  }
+  const parsed = JSON.parse(result.stdout.trim()) as ClaudeKeychainPayload
+  const access = parsed.claudeAiOauth?.accessToken
+  if (!access) {
+    throw new Error('no accessToken in Claude Code keychain')
+  }
+  cachedCreds = { accessToken: access, expiresAt: parsed.claudeAiOauth?.expiresAt }
+  return cachedCreds
+}
+
+function formatRemainingFromIso(iso: string | undefined): string | null {
+  if (!iso) return null
+  const ms = new Date(iso).getTime() - Date.now()
+  if (ms <= 0) return null
+  const totalMin = Math.round(ms / 60_000)
+  const h = Math.floor(totalMin / 60)
+  const m = totalMin % 60
+  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}h`
+}
+
+export async function fetchClaudeUsage(_config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  const now = new Date().toISOString()
+  const base: UsageSnapshot = {
+    burnRatePerHour: null,
+    costUSD: null,
+    lastUpdated: now,
+    percent: null,
+    resetAt: null,
+    timeRemaining: null,
+    tokens: { cache: 0, input: 0, output: 0, total: 0 },
+    tool: 'claude',
+  }
+
+  try {
+    const creds = await readClaudeCreds()
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
+    let response: Response
+    try {
+      response = await fetch(USAGE_URL, {
+        headers: {
+          'anthropic-beta': OAUTH_BETA_HEADER,
+          'Authorization': `Bearer ${creds.accessToken}`,
+          'Content-Type': 'application/json',
+        },
+        signal: controller.signal,
+      })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      cachedCreds = null
+      return { ...base, error: 'claude oauth expired — run `claude` to re-auth' }
+    }
+    if (!response.ok) {
+      return { ...base, error: `claude api ${response.status}` }
+    }
+
+    const parsed = (await response.json()) as ClaudeUsageResponse
+    const fiveHour = parsed.five_hour
+    const utilization = typeof fiveHour?.utilization === 'number' ? fiveHour.utilization : null
+    const percent = utilization === null ? null : Math.max(0, Math.min(100, utilization))
+
+    return {
+      ...base,
+      percent,
+      resetAt: fiveHour?.resets_at ?? null,
+      timeRemaining: formatRemainingFromIso(fiveHour?.resets_at),
+      tool: 'claude',
+    }
+  } catch (error) {
+    return {
+      ...base,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}

package/src/services/ai-usage/adapters/codex.ts

@@ -0,0 +1,191 @@
+import type { AIUsageToolConfig } from '@brimveyn/aimux-config'
+
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { UsageSnapshot } from '../types'
+
+interface CodexAuthFile {
+  tokens?: {
+    access_token?: string
+    account_id?: string
+  }
+}
+
+interface WindowSnapshot {
+  used_percent?: number
+  reset_at?: number
+  limit_window_seconds?: number
+}
+
+interface CodexUsageResponse {
+  plan_type?: string
+  rate_limit?: {
+    primary_window?: WindowSnapshot | null
+    secondary_window?: WindowSnapshot | null
+  }
+  credits?: {
+    has_credits?: boolean
+    unlimited?: boolean
+    balance?: number | string | null
+  }
+}
+
+const DEFAULT_CHATGPT_BASE = 'https://chatgpt.com/backend-api'
+const USAGE_PATH = '/wham/usage'
+const AUTH_TIMEOUT_MS = 15_000
+
+function codexHome(): string {
+  const env = process.env.CODEX_HOME?.trim()
+  if (env) return env
+  return join(homedir(), '.codex')
+}
+
+function parseChatGPTBaseFromConfig(contents: string): string | null {
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.split('#', 1)[0]?.trim() ?? ''
+    if (!line) continue
+    const eq = line.indexOf('=')
+    if (eq < 0) continue
+    const key = line.slice(0, eq).trim()
+    if (key !== 'chatgpt_base_url') continue
+    let value = line.slice(eq + 1).trim()
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+    return value.trim()
+  }
+  return null
+}
+
+function normalizeBase(value: string): string {
+  let trimmed = value.trim() || DEFAULT_CHATGPT_BASE
+  while (trimmed.endsWith('/')) trimmed = trimmed.slice(0, -1)
+  if (
+    (trimmed.startsWith('https://chatgpt.com') || trimmed.startsWith('https://chat.openai.com')) &&
+    !trimmed.includes('/backend-api')
+  ) {
+    trimmed += '/backend-api'
+  }
+  return trimmed
+}
+
+async function resolveUsageURL(): Promise<string> {
+  let base = DEFAULT_CHATGPT_BASE
+  try {
+    const contents = await readFile(join(codexHome(), 'config.toml'), 'utf8')
+    const parsed = parseChatGPTBaseFromConfig(contents)
+    if (parsed) base = parsed
+  } catch {
+    // no config.toml or unreadable — fall back to default
+  }
+  const normalized = normalizeBase(base)
+  const path = normalized.includes('/backend-api') ? USAGE_PATH : '/api/codex/usage'
+  return normalized + path
+}
+
+async function loadAuth(): Promise<{ accessToken: string; accountId: string | null }> {
+  const raw = await readFile(join(codexHome(), 'auth.json'), 'utf8')
+  const parsed = JSON.parse(raw) as CodexAuthFile
+  const accessToken = parsed.tokens?.access_token
+  if (!accessToken) {
+    throw new Error('no access_token in ~/.codex/auth.json — run `codex` to sign in')
+  }
+  return {
+    accessToken,
+    accountId: parsed.tokens?.account_id ?? null,
+  }
+}
+
+function formatRemainingFromReset(resetAtSeconds: number | undefined): string | null {
+  if (!resetAtSeconds) return null
+  const diffMs = resetAtSeconds * 1000 - Date.now()
+  if (diffMs <= 0) return null
+  const totalMin = Math.round(diffMs / 60_000)
+  const h = Math.floor(totalMin / 60)
+  const m = totalMin % 60
+  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}h`
+}
+
+function pickPrimaryWindow(rate: CodexUsageResponse['rate_limit']): WindowSnapshot | null {
+  if (!rate) return null
+  // Primary = 5h session window. Pick the one closest to 300 minutes (18000s),
+  // falling back to whichever is defined.
+  const windows = [rate.primary_window, rate.secondary_window].filter(
+    (w): w is WindowSnapshot => !!w
+  )
+  if (windows.length === 0) return null
+  const sessionWindow = windows.find((w) => w.limit_window_seconds === 18_000)
+  return sessionWindow ?? windows[0] ?? null
+}
+
+export async function fetchCodexUsage(_config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  const now = new Date().toISOString()
+  const base: UsageSnapshot = {
+    burnRatePerHour: null,
+    costUSD: null,
+    lastUpdated: now,
+    percent: null,
+    resetAt: null,
+    timeRemaining: null,
+    tokens: { cache: 0, input: 0, output: 0, total: 0 },
+    tool: 'codex',
+  }
+
+  try {
+    const { accessToken, accountId } = await loadAuth()
+    const url = await resolveUsageURL()
+
+    const headers: Record<string, string> = {
+      'Accept': 'application/json',
+      'Authorization': `Bearer ${accessToken}`,
+      'User-Agent': 'aimux',
+    }
+    if (accountId) headers['ChatGPT-Account-Id'] = accountId
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), AUTH_TIMEOUT_MS)
+    let response: Response
+    try {
+      response = await fetch(url, { headers, signal: controller.signal })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      return { ...base, error: 'codex oauth expired — run `codex` to re-auth' }
+    }
+    if (!response.ok) {
+      return { ...base, error: `codex api ${response.status}` }
+    }
+
+    const parsed = (await response.json()) as CodexUsageResponse
+    const window = pickPrimaryWindow(parsed.rate_limit)
+    if (!window) {
+      return { ...base, error: 'no rate_limit data' }
+    }
+
+    const percent =
+      typeof window.used_percent === 'number'
+        ? Math.max(0, Math.min(100, window.used_percent))
+        : null
+    const resetAt = window.reset_at ? new Date(window.reset_at * 1000).toISOString() : null
+
+    return {
+      ...base,
+      percent,
+      resetAt,
+      timeRemaining: formatRemainingFromReset(window.reset_at),
+      tool: 'codex',
+    }
+  } catch (error) {
+    return {
+      ...base,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}

package/src/services/ai-usage/provider.ts

@@ -0,0 +1,84 @@
+import type { AIUsageTool, AIUsageToolConfig } from '@brimveyn/aimux-config'
+
+import type { UsageSnapshot } from './types'
+
+import { fetchClaudeUsage } from './adapters/claude'
+import { fetchCodexUsage } from './adapters/codex'
+
+const DEFAULT_POLL_SECONDS = 60
+const DEFAULT_TOOLS: AIUsageTool[] = ['claude', 'codex']
+
+export interface AIUsageServiceHandle {
+  stop: () => void
+  refresh: () => void
+}
+
+async function fetchFor(tool: AIUsageTool, config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  switch (tool) {
+    case 'claude':
+      return fetchClaudeUsage(config)
+    case 'codex':
+      return fetchCodexUsage(config)
+  }
+}
+
+export function startAIUsageService(
+  config: AIUsageToolConfig,
+  onUpdate: (snap: UsageSnapshot) => void
+): AIUsageServiceHandle {
+  const tools = config.tools && config.tools.length > 0 ? config.tools : DEFAULT_TOOLS
+  const pollMs = Math.max(5, config.pollSeconds ?? DEFAULT_POLL_SECONDS) * 1000
+
+  let stopped = false
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  const tick = async (): Promise<void> => {
+    if (stopped) return
+    const results = await Promise.allSettled(tools.map((t) => fetchFor(t, config)))
+    if (stopped) return
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]
+      const tool = tools[i]
+      if (!result || !tool) continue
+      if (result.status === 'fulfilled') {
+        onUpdate(result.value)
+      } else {
+        onUpdate({
+          burnRatePerHour: null,
+          costUSD: null,
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+          lastUpdated: new Date().toISOString(),
+          percent: null,
+          resetAt: null,
+          timeRemaining: null,
+          tokens: { cache: 0, input: 0, output: 0, total: 0 },
+          tool,
+        })
+      }
+    }
+    if (!stopped) {
+      timer = setTimeout(() => {
+        void tick()
+      }, pollMs)
+    }
+  }
+
+  void tick()
+
+  return {
+    refresh: () => {
+      if (timer) {
+        clearTimeout(timer)
+        timer = null
+      }
+      void tick()
+    },
+    stop: () => {
+      stopped = true
+      if (timer) {
+        clearTimeout(timer)
+        timer = null
+      }
+    },
+  }
+}

package/src/services/ai-usage/spawn.ts

@@ -0,0 +1,49 @@
+interface CliResult {
+  ok: boolean
+  stdout: string
+  stderr: string
+  error?: string
+}
+
+const DEFAULT_TIMEOUT_MS = 15_000
+
+export async function runCli(
+  command: string,
+  args: string[],
+  timeoutMs: number = DEFAULT_TIMEOUT_MS
+): Promise<CliResult> {
+  const proc = Bun.spawn([command, ...args], {
+    stderr: 'pipe',
+    stdin: 'ignore',
+    stdout: 'pipe',
+  })
+
+  const timeout = setTimeout(() => {
+    try {
+      proc.kill()
+    } catch {
+      // process already gone
+    }
+  }, timeoutMs)
+
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ])
+
+    if (exitCode !== 0) {
+      return {
+        error: `${command} exit ${exitCode}: ${stderr.trim().slice(0, 200)}`,
+        ok: false,
+        stderr,
+        stdout,
+      }
+    }
+
+    return { ok: true, stderr, stdout }
+  } finally {
+    clearTimeout(timeout)
+  }
+}

package/src/services/ai-usage/types.ts

@@ -0,0 +1,20 @@
+import type { AIUsageTool } from '@brimveyn/aimux-config'
+
+export type { AIUsageTool }
+
+export interface UsageSnapshot {
+  tool: AIUsageTool
+  percent: number | null
+  tokens: {
+    input: number
+    output: number
+    cache: number
+    total: number
+  }
+  costUSD: number | null
+  resetAt: string | null
+  timeRemaining: string | null
+  burnRatePerHour: number | null
+  lastUpdated: string
+  error?: string
+}