Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

add session output token sparklines

Raine Virta60fd22b8403f
diff --git a/src/monitor.rs b/src/monitor.rs
index 7d9a941..57bb24a 100644
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -10,6 +10,7 @@ mod mock;
pub use mock::{MockMonitor, mock_state};
const DEFAULT_RECENT_LIMIT: usize = 200;
+pub const SESSION_TOKEN_BUCKET_SECS: u64 = 10;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EndpointKind {
@@ -235,6 +236,7 @@ pub struct SessionSummary {
pub last_seen: SystemTime,
pub input_tokens: u64,
pub output_tokens: u64,
+ pub output_token_samples: Vec<(SystemTime, u64)>,
rate_output_tokens: u64,
pub generation_duration: Duration,
pub last_status: String,
@@ -262,6 +264,7 @@ struct MonitorStore {
started_at: SystemTime,
active: HashMap<String, ActiveRequest>,
recent: VecDeque<CompletedRequest>,
+ session_output_buckets: HashMap<Option<String>, Vec<(u64, u64)>>,
recent_limit: usize,
}
@@ -283,6 +286,7 @@ impl MonitorHandle {
started_at: SystemTime::now(),
active: HashMap::new(),
recent: VecDeque::new(),
+ session_output_buckets: HashMap::new(),
recent_limit,
})),
}
@@ -528,6 +532,7 @@ impl MonitorStore {
input_tokens,
output_tokens,
} => {
+ let mut history_update = None;
if let Some(active) = self.active.get_mut(&request_id) {
active.status = RequestStatus::Streaming;
if active.generation_started_instant.is_none() {
@@ -550,6 +555,7 @@ impl MonitorStore {
.iter_mut()
.find(|request| request.request_id == request_id)
{
+ let previous_output_tokens = completed.output_tokens.unwrap_or(0);
if let Some(started) = completed.generation_started_instant {
completed.generation_finished_at = Some(SystemTime::now());
completed.generation_duration = Some(started.elapsed());
@@ -558,6 +564,22 @@ impl MonitorStore {
completed.stream_chunks = completed.stream_chunks.saturating_add(chunks);
completed.input_tokens = input_tokens.or(completed.input_tokens);
completed.output_tokens = output_tokens.or(completed.output_tokens);
+ let added_tokens = completed
+ .output_tokens
+ .unwrap_or(0)
+ .saturating_sub(previous_output_tokens);
+ if added_tokens > 0 {
+ history_update = Some((
+ completed.session_id.clone(),
+ completed
+ .generation_finished_at
+ .unwrap_or(completed.finished_at),
+ added_tokens,
+ ));
+ }
+ }
+ if let Some((session_id, timestamp, tokens)) = history_update {
+ self.record_session_output(session_id, timestamp, tokens);
}
}
MonitorEvent::UsageUpdated {
@@ -565,6 +587,7 @@ impl MonitorStore {
input_tokens,
output_tokens,
} => {
+ let mut history_update = None;
if let Some(active) = self.active.get_mut(&request_id) {
if output_tokens.is_some()
&& let Some(started) = active.generation_started_instant
@@ -579,6 +602,7 @@ impl MonitorStore {
.iter_mut()
.find(|request| request.request_id == request_id)
{
+ let previous_output_tokens = completed.output_tokens.unwrap_or(0);
if output_tokens.is_some()
&& let Some(started) = completed.generation_started_instant
{
@@ -587,6 +611,22 @@ impl MonitorStore {
}
completed.input_tokens = input_tokens.or(completed.input_tokens);
completed.output_tokens = output_tokens.or(completed.output_tokens);
+ let added_tokens = completed
+ .output_tokens
+ .unwrap_or(0)
+ .saturating_sub(previous_output_tokens);
+ if added_tokens > 0 {
+ history_update = Some((
+ completed.session_id.clone(),
+ completed
+ .generation_finished_at
+ .unwrap_or(completed.finished_at),
+ added_tokens,
+ ));
+ }
+ }
+ if let Some((session_id, timestamp, tokens)) = history_update {
+ self.record_session_output(session_id, timestamp, tokens);
}
}
MonitorEvent::RequestCompleted {
@@ -720,16 +760,39 @@ impl MonitorStore {
error: error.or(active.error),
traffic_capture_path: active.traffic_capture_path,
};
+ if let Some(tokens) = completed.output_tokens.filter(|tokens| *tokens > 0) {
+ self.record_session_output(
+ completed.session_id.clone(),
+ completed
+ .generation_finished_at
+ .unwrap_or(completed.finished_at),
+ tokens,
+ );
+ }
self.recent.push_front(completed);
while self.recent.len() > self.recent_limit {
self.recent.pop_back();
}
}
+ fn record_session_output(
+ &mut self,
+ session_id: Option<String>,
+ timestamp: SystemTime,
+ tokens: u64,
+ ) {
+ let bucket = session_token_bucket(timestamp);
+ let buckets = self.session_output_buckets.entry(session_id).or_default();
+ match buckets.binary_search_by_key(&bucket, |(bucket, _)| *bucket) {
+ Ok(index) => buckets[index].1 = buckets[index].1.saturating_add(tokens),
+ Err(index) => buckets.insert(index, (bucket, tokens)),
+ }
+ }
+
fn snapshot(&self) -> MonitorState {
let mut active: Vec<_> = self.active.values().cloned().collect();
active.sort_by_key(|request| request.started_at);
- let sessions = session_summaries(&active, &self.recent);
+ let sessions = session_summaries(&active, &self.recent, &self.session_output_buckets);
MonitorState {
started_at: self.started_at,
sessions,
@@ -742,6 +805,7 @@ impl MonitorStore {
fn session_summaries(
active: &[ActiveRequest],
recent: &VecDeque<CompletedRequest>,
+ session_output_buckets: &HashMap<Option<String>, Vec<(u64, u64)>>,
) -> Vec<SessionSummary> {
let mut sessions: HashMap<Option<String>, SessionSummary> = HashMap::new();
for request in recent.iter().rev() {
@@ -759,6 +823,7 @@ fn session_summaries(
last_seen: request.finished_at,
input_tokens: 0,
output_tokens: 0,
+ output_token_samples: Vec::new(),
rate_output_tokens: 0,
generation_duration: Duration::ZERO,
last_status: "-".to_string(),
@@ -808,6 +873,7 @@ fn session_summaries(
last_seen: request.started_at,
input_tokens: 0,
output_tokens: 0,
+ output_token_samples: Vec::new(),
rate_output_tokens: 0,
generation_duration: Duration::ZERO,
last_status: "-".to_string(),
@@ -840,11 +906,32 @@ fn session_summaries(
entry.last_status = request.status.label().to_string();
}
+ for (session_id, session) in &mut sessions {
+ if let Some(buckets) = session_output_buckets.get(session_id) {
+ session.output_token_samples = buckets
+ .iter()
+ .map(|(bucket, tokens)| (session_token_bucket_start(*bucket), *tokens))
+ .collect();
+ }
+ }
+
let mut out: Vec<_> = sessions.into_values().collect();
out.sort_by_key(SessionSummary::label);
out
}
+fn session_token_bucket(timestamp: SystemTime) -> u64 {
+ timestamp
+ .duration_since(SystemTime::UNIX_EPOCH)
+ .unwrap_or(Duration::ZERO)
+ .as_secs()
+ / SESSION_TOKEN_BUCKET_SECS
+}
+
+fn session_token_bucket_start(bucket: u64) -> SystemTime {
+ SystemTime::UNIX_EPOCH + Duration::from_secs(bucket.saturating_mul(SESSION_TOKEN_BUCKET_SECS))
+}
+
fn max_system_time(left: SystemTime, right: SystemTime) -> SystemTime {
if right.duration_since(left).is_ok() {
right
@@ -1001,6 +1088,14 @@ mod tests {
state.recent[0].rate(),
Throughput::TokensPerSecond(_)
));
+ assert_eq!(
+ state.sessions[0]
+ .output_token_samples
+ .iter()
+ .map(|(_, tokens)| *tokens)
+ .sum::<u64>(),
+ 141
+ );
}
#[test]
@@ -1181,7 +1276,7 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input
),
]);
- let sessions = session_summaries(&[], &recent);
+ let sessions = session_summaries(&[], &recent, &HashMap::new());
assert_eq!(sessions[0].output_tokens, 150);
assert_eq!(sessions[0].generation_duration, Duration::from_secs(5));
@@ -1194,7 +1289,10 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input
let recent = VecDeque::from([request.clone()]);
assert_eq!(request.rate(), Throughput::None);
- assert_eq!(session_summaries(&[], &recent)[0].rate(), Throughput::None);
+ assert_eq!(
+ session_summaries(&[], &recent, &HashMap::new())[0].rate(),
+ Throughput::None
+ );
}
#[test]
@@ -1219,7 +1317,7 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input
]);
assert_eq!(
- session_summaries(&[], &recent)[0].rate(),
+ session_summaries(&[], &recent, &HashMap::new())[0].rate(),
Throughput::TokensPerSecond(25.0)
);
}
@@ -1237,7 +1335,7 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input
),
]);
- let session = &session_summaries(&[], &recent)[0];
+ let session = &session_summaries(&[], &recent, &HashMap::new())[0];
assert_eq!(session.output_tokens, 1_000);
assert_eq!(session.rate(), Throughput::TokensPerSecond(25.0));
@@ -1270,6 +1368,40 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input
assert_eq!(state.sessions[0].active_count, 1);
assert_eq!(state.sessions[0].effort.as_deref(), Some("xhigh"));
assert_eq!(state.sessions[0].output_tokens, 20);
+ assert_eq!(
+ state.sessions[0]
+ .output_token_samples
+ .iter()
+ .map(|(_, tokens)| *tokens)
+ .collect::<Vec<_>>(),
+ vec![20]
+ );
+ }
+
+ #[test]
+ fn session_output_history_survives_request_eviction() {
+ let monitor = MonitorHandle::new(1);
+ for (request_id, tokens) in [("oldest", 20), ("newest", 80)] {
+ monitor.request_started(
+ request_id,
+ Some("s1".to_string()),
+ None,
+ EndpointKind::Messages,
+ );
+ monitor.request_completed(request_id, 200, None, Some(tokens));
+ }
+
+ let state = monitor.snapshot();
+
+ assert_eq!(state.recent.len(), 1);
+ assert_eq!(
+ state.sessions[0]
+ .output_token_samples
+ .iter()
+ .map(|(_, tokens)| *tokens)
+ .sum::<u64>(),
+ 100
+ );
}
#[test]
diff --git a/src/monitor/mock.rs b/src/monitor/mock.rs
index 382d79a..afbdc70 100644
--- a/src/monitor/mock.rs
+++ b/src/monitor/mock.rs
@@ -1,5 +1,5 @@
use std::{
- collections::VecDeque,
+ collections::{HashMap, VecDeque},
path::PathBuf,
time::{Duration, Instant, SystemTime},
};
@@ -333,7 +333,8 @@ fn mock_state_for_tick(
recent.push_back(no_status);
add_simulated_requests(now, instant_now, tick, &mut active, &mut recent);
- let sessions = session_summaries(&active, &recent);
+ let output_buckets = simulated_output_buckets(now, tick, &active, &recent);
+ let sessions = session_summaries(&active, &recent, &output_buckets);
MonitorState {
started_at,
sessions,
@@ -342,6 +343,94 @@ fn mock_state_for_tick(
}
}
+fn simulated_output_buckets(
+ now: SystemTime,
+ tick: u64,
+ active: &[ActiveRequest],
+ recent: &VecDeque<CompletedRequest>,
+) -> HashMap<Option<String>, Vec<(u64, u64)>> {
+ const HISTORIES: [(&str, [u64; 12]); 3] = [
+ (
+ "57c7c914-ada4-4f40-9672-985f950fbb66",
+ [0, 320, 780, 0, 1_600, 2_900, 850, 0, 440, 3_600, 2_200, 0],
+ ),
+ (
+ "terminal-refactor",
+ [180, 0, 420, 960, 0, 0, 1_300, 740, 2_100, 0, 350, 0],
+ ),
+ (
+ "cursor-session",
+ [0, 640, 1_200, 2_400, 3_800, 1_900, 0, 0, 820, 1_500, 0, 0],
+ ),
+ ];
+
+ let current_bucket = super::session_token_bucket(now);
+ let mut buckets = HashMap::<Option<String>, Vec<(u64, u64)>>::new();
+ for (session_id, history) in HISTORIES {
+ for (index, tokens) in history.iter().copied().enumerate() {
+ if tokens == 0 {
+ continue;
+ }
+ let offset = (history.len() - 1 - index) as u64;
+ record_output_bucket(
+ &mut buckets,
+ Some(session_id.to_string()),
+ current_bucket.saturating_sub(offset),
+ tokens,
+ );
+ }
+ }
+
+ for request in recent {
+ if let Some(tokens) = request.output_tokens.filter(|tokens| *tokens > 0) {
+ record_output_bucket(
+ &mut buckets,
+ request.session_id.clone(),
+ super::session_token_bucket(request.finished_at),
+ tokens,
+ );
+ }
+ }
+ for request in active {
+ if let Some(tokens) = request.output_tokens.filter(|tokens| *tokens > 0) {
+ record_output_bucket(
+ &mut buckets,
+ request.session_id.clone(),
+ current_bucket,
+ tokens,
+ );
+ }
+ }
+
+ record_output_bucket(
+ &mut buckets,
+ Some("57c7c914-ada4-4f40-9672-985f950fbb66".to_string()),
+ current_bucket,
+ 120 + (tick % 40) * 80,
+ );
+ for samples in buckets.values_mut() {
+ samples.sort_by_key(|(bucket, _)| *bucket);
+ }
+ buckets
+}
+
+fn record_output_bucket(
+ buckets: &mut HashMap<Option<String>, Vec<(u64, u64)>>,
+ session_id: Option<String>,
+ bucket: u64,
+ tokens: u64,
+) {
+ let samples = buckets.entry(session_id).or_default();
+ if let Some((_, existing)) = samples
+ .iter_mut()
+ .find(|(existing_bucket, _)| *existing_bucket == bucket)
+ {
+ *existing = existing.saturating_add(tokens);
+ } else {
+ samples.push((bucket, tokens));
+ }
+}
+
fn simulated_output_tokens(tick: u64) -> u64 {
let pairs = tick / 2;
pairs
@@ -679,6 +768,10 @@ mod tests {
assert!(second_request.output_tokens > first_request.output_tokens);
assert_ne!(second_request.rate(), first_request.rate());
assert!(second_session.output_tokens > first_session.output_tokens);
+ assert_ne!(
+ second_session.output_token_samples,
+ first_session.output_token_samples
+ );
assert_eq!(second.started_at, first.started_at);
}
diff --git a/src/tui.rs b/src/tui.rs
index 2e6fc2c..8ccc2d9 100644
--- a/src/tui.rs
+++ b/src/tui.rs
@@ -1,4 +1,5 @@
use std::{
+ collections::HashMap,
io::{self, Stdout},
time::{Duration, SystemTime},
};
@@ -21,7 +22,8 @@ use tokio::sync::oneshot;
use crate::{
monitor::{
- ActiveRequest, CompletedRequest, MockMonitor, MonitorHandle, MonitorState, SessionSummary,
+ ActiveRequest, CompletedRequest, MockMonitor, MonitorHandle, MonitorState,
+ SESSION_TOKEN_BUCKET_SECS, SessionSummary,
},
paths,
registry::Registry,
@@ -41,6 +43,9 @@ const BLUE: Color = Color::Rgb(120, 170, 230);
const DIM: Color = Color::Rgb(100, 104, 114);
const RECENT_MODEL_WIDTH: u16 = 36;
+const SESSION_SPARKLINE_MIN_WIDTH: u16 = 170;
+const SESSION_SPARKLINE_MAX_TOKENS: u64 = 4_000;
+
const SESSION_TABLE_HEADERS: [(&str, Alignment); 13] = [
("", Alignment::Left),
("ID", Alignment::Left),
@@ -57,6 +62,23 @@ const SESSION_TABLE_HEADERS: [(&str, Alignment); 13] = [
("Status", Alignment::Left),
];
+const SESSION_WIDE_TABLE_HEADERS: [(&str, Alignment); 14] = [
+ ("", Alignment::Left),
+ ("ID", Alignment::Left),
+ ("Project", Alignment::Left),
+ ("Active", Alignment::Right),
+ ("Reqs", Alignment::Right),
+ ("Fail", Alignment::Right),
+ ("Provider", Alignment::Left),
+ ("Model", Alignment::Left),
+ ("Effort", Alignment::Left),
+ ("In", Alignment::Right),
+ ("Out", Alignment::Right),
+ ("Rate", Alignment::Right),
+ ("Tokens/10s · 4k", Alignment::Left),
+ ("Status", Alignment::Left),
+];
+
const ACTIVE_TABLE_HEADERS: [(&str, Alignment); 8] = [
("Started", Alignment::Left),
("Provider", Alignment::Left),
@@ -635,6 +657,62 @@ fn spinner(tick: usize) -> &'static str {
FRAMES[tick % FRAMES.len()]
}
+fn sparkline_bucket(timestamp: SystemTime) -> u64 {
+ timestamp
+ .duration_since(SystemTime::UNIX_EPOCH)
+ .unwrap_or(Duration::ZERO)
+ .as_secs()
+ / SESSION_TOKEN_BUCKET_SECS
+}
+
+fn token_sparkline(samples: &[(SystemTime, u64)], width: usize, now: SystemTime) -> String {
+ const LEVELS: [char; 8] = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+
+ if width == 0 {
+ return String::new();
+ }
+
+ let mut buckets = HashMap::<u64, u64>::new();
+ for (timestamp, tokens) in samples {
+ let bucket = sparkline_bucket(*timestamp);
+ let total = buckets.entry(bucket).or_default();
+ *total = total.saturating_add(*tokens);
+ }
+
+ let current_bucket = sparkline_bucket(now);
+ let first_bucket = current_bucket.saturating_sub(width.saturating_sub(1) as u64);
+ (first_bucket..=current_bucket)
+ .map(|bucket| {
+ let value = buckets.get(&bucket).copied().unwrap_or(0);
+ if value == 0 {
+ return ' ';
+ }
+ let scaled = value.min(SESSION_SPARKLINE_MAX_TOKENS);
+ let level = ((u128::from(scaled) * LEVELS.len() as u128
+ + u128::from(SESSION_SPARKLINE_MAX_TOKENS)
+ - 1)
+ / u128::from(SESSION_SPARKLINE_MAX_TOKENS))
+ .saturating_sub(1) as usize;
+ LEVELS[level]
+ })
+ .collect()
+}
+
+fn token_sparkline_line(
+ samples: &[(SystemTime, u64)],
+ width: usize,
+ now: SystemTime,
+) -> Line<'static> {
+ let mut sparkline = token_sparkline(samples, width, now);
+ let current = sparkline
+ .pop()
+ .map_or_else(String::new, |value| value.to_string());
+ Line::from(vec![
+ Span::styled(sparkline, Style::default().fg(BLUE)),
+ Span::styled(current, Style::default().fg(DIM)),
+ ])
+}
+
fn render_sessions(
frame: &mut ratatui::Frame<'_>,
area: Rect,
@@ -647,7 +725,8 @@ fn render_sessions(
return;
}
- let widths = [
+ let show_sparkline = area.width >= SESSION_SPARKLINE_MIN_WIDTH;
+ let mut widths = vec![
Constraint::Length(1),
Constraint::Length(8),
Constraint::Length(18),
@@ -660,16 +739,23 @@ fn render_sessions(
Constraint::Length(9),
Constraint::Length(9),
Constraint::Length(12),
- Constraint::Length(10),
];
+ if show_sparkline {
+ widths.push(Constraint::Fill(1));
+ }
+ widths.push(Constraint::Length(10));
let model_width = table_column_width(area, &widths, 7);
+ let sparkline_width = show_sparkline
+ .then(|| table_column_width(area, &widths, 12))
+ .unwrap_or(0);
+ let now = SystemTime::now();
let rows = sessions.iter().enumerate().map(|(index, session)| {
let marker = if focused && index == selected {
">"
} else {
" "
};
- Row::new(vec![
+ let mut cells = vec![
Cell::from(Span::styled(marker, Style::default().fg(TEAL))),
text_cell(display_session_id(session.session_id.as_deref())),
text_cell(session.project.as_deref().unwrap_or("-")),
@@ -682,16 +768,28 @@ fn render_sessions(
number_cell(compact_tokens(session.input_tokens)),
number_cell(compact_tokens(session.output_tokens)),
rate_cell(session.rate().label()),
- status_cell(&session.last_status),
- ])
- .style(if index == selected {
+ ];
+ if show_sparkline {
+ cells.push(Cell::from(token_sparkline_line(
+ &session.output_token_samples,
+ sparkline_width,
+ now,
+ )));
+ }
+ cells.push(status_cell(&session.last_status));
+ Row::new(cells).style(if index == selected {
Style::default().bg(SELECTED_BG)
} else {
Style::default().bg(PANEL_BG)
})
});
+ let headers: &[(&str, Alignment)] = if show_sparkline {
+ &SESSION_WIDE_TABLE_HEADERS
+ } else {
+ &SESSION_TABLE_HEADERS
+ };
let table = Table::new(rows, widths)
- .header(table_header_aligned(SESSION_TABLE_HEADERS))
+ .header(table_header_aligned(headers.iter().copied()))
.block(panel("Sessions", focused));
frame.render_widget(table, area);
}
@@ -1290,6 +1388,25 @@ mod tests {
"Out", "Rate", "Status",
]
);
+ assert_eq!(
+ table_header_labels(&SESSION_WIDE_TABLE_HEADERS),
+ [
+ "",
+ "ID",
+ "Project",
+ "Active",
+ "Reqs",
+ "Fail",
+ "Provider",
+ "Model",
+ "Effort",
+ "In",
+ "Out",
+ "Rate",
+ "Tokens/10s · 4k",
+ "Status",
+ ]
+ );
assert_eq!(
table_header_labels(&ACTIVE_TABLE_HEADERS),
[
@@ -1386,6 +1503,95 @@ mod tests {
assert_eq!(ellipsize("anything", 0), "");
}
+ #[test]
+ fn token_sparkline_uses_fixed_wall_clock_buckets() {
+ let samples = [
+ (SystemTime::UNIX_EPOCH + Duration::from_secs(78), 2_000),
+ (SystemTime::UNIX_EPOCH + Duration::from_secs(85), 3_000),
+ (SystemTime::UNIX_EPOCH + Duration::from_secs(100), 4_000),
+ ];
+ let bucket_start = SystemTime::UNIX_EPOCH + Duration::from_secs(100);
+ let bucket_end = SystemTime::UNIX_EPOCH + Duration::from_secs(109);
+ let next_bucket = SystemTime::UNIX_EPOCH + Duration::from_secs(110);
+
+ assert_eq!(token_sparkline(&[], 4, bucket_start), " ");
+ assert_eq!(token_sparkline(&samples, 4, bucket_start), "▄▆ █");
+ assert_eq!(token_sparkline(&samples, 4, bucket_end), "▄▆ █");
+ assert_eq!(token_sparkline(&samples, 4, next_bucket), "▆ █ ");
+ assert_eq!(token_sparkline(&samples, 0, bucket_start), "");
+ }
+
+ #[test]
+ fn token_sparkline_uses_fixed_shared_scale() {
+ let now = SystemTime::UNIX_EPOCH + Duration::from_secs(100);
+ let current = (now, 2_000);
+ let offscreen_peak = (SystemTime::UNIX_EPOCH, 4_000);
+
+ assert_eq!(token_sparkline(&[current], 2, now), " ▄");
+ assert_eq!(token_sparkline(&[offscreen_peak, current], 2, now), " ▄");
+ assert_eq!(token_sparkline(&[(now, 10_000)], 1, now), "█");
+ }
+
+ #[test]
+ fn token_sparkline_dims_the_current_bucket() {
+ let now = SystemTime::UNIX_EPOCH + Duration::from_secs(100);
+ let samples = [
+ (SystemTime::UNIX_EPOCH + Duration::from_secs(95), 2_000),
+ (now, 4_000),
+ ];
+
+ let line = token_sparkline_line(&samples, 2, now);
+
+ assert_eq!(line.spans[0].content, "▄");
+ assert_eq!(line.spans[0].style.fg, Some(BLUE));
+ assert_eq!(line.spans[1].content, "█");
+ assert_eq!(line.spans[1].style.fg, Some(DIM));
+ }
+
+ #[test]
+ fn session_sparkline_appears_only_when_space_allows_and_expands() {
+ let monitor = MonitorHandle::new(10);
+ for (index, tokens) in [1_000, 2_000, 4_000].into_iter().enumerate() {
+ let request_id = format!("request-{index}");
+ monitor.request_started(
+ &request_id,
+ Some("sess-1".to_string()),
+ Some(index as u64 + 1),
+ EndpointKind::Messages,
+ );
+ monitor.provider_selected(&request_id, "codex", "gpt-5.6-sol", None);
+ monitor.request_completed(&request_id, 200, Some(100), Some(tokens));
+ }
+ let state = monitor.snapshot();
+
+ let narrow = draw(SESSION_SPARKLINE_MIN_WIDTH - 1, 8, |frame| {
+ render_sessions(frame, frame.area(), &state.sessions, 0, true)
+ });
+ let wide = draw(SESSION_SPARKLINE_MIN_WIDTH, 8, |frame| {
+ render_sessions(frame, frame.area(), &state.sessions, 0, true)
+ });
+ let wider = draw(SESSION_SPARKLINE_MIN_WIDTH + 30, 8, |frame| {
+ render_sessions(frame, frame.area(), &state.sessions, 0, true)
+ });
+ let narrow_text = buffer_text(&narrow);
+ let wide_text = buffer_text(&wide);
+ let wider_text = buffer_text(&wider);
+ let spark_chars = |text: &str| {
+ text.chars()
+ .filter(|ch| matches!(ch, '▁' | '▂' | '▃' | '▄' | '▅' | '▆' | '▇' | '█'))
+ .count()
+ };
+
+ assert!(!narrow_text.contains("Tokens/10s"), "{narrow_text}");
+ assert_eq!(spark_chars(&narrow_text), 0, "{narrow_text}");
+ assert!(wide_text.contains("Tokens/10s"), "{wide_text}");
+ assert!(spark_chars(&wide_text) > 0, "{wide_text}");
+ assert!(
+ wider_text.find("█ completed") > wide_text.find("█ completed"),
+ "{wider_text}"
+ );
+ }
+
#[test]
fn empty_tables_hide_columns_and_center_placeholders() {
let sessions = draw(40, 9, |frame| {