Skip to content

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

Rust

show session activity in monitor

Raine Virta6b6ac124f04f
diff --git a/src/monitor.rs b/src/monitor.rs
index a028018..3e0c7d9 100644
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -181,10 +181,43 @@ impl Throughput {
#[derive(Debug, Clone)]
pub struct MonitorState {
pub started_at: SystemTime,
+ pub sessions: Vec<SessionSummary>,
pub active: Vec<ActiveRequest>,
pub recent: Vec<CompletedRequest>,
}
+#[derive(Debug, Clone)]
+pub struct SessionSummary {
+ pub session_id: Option<String>,
+ pub active_count: usize,
+ pub request_count: usize,
+ pub failure_count: usize,
+ pub provider: Option<String>,
+ pub model: Option<String>,
+ pub last_seen: SystemTime,
+ pub input_tokens: u64,
+ pub output_tokens: u64,
+ pub elapsed: Duration,
+ pub last_status: String,
+}
+
+impl SessionSummary {
+ pub fn rate(&self) -> Throughput {
+ throughput(
+ Some(self.output_tokens).filter(|tokens| *tokens > 0),
+ 0,
+ 0,
+ self.elapsed,
+ )
+ }
+
+ pub fn label(&self) -> String {
+ self.session_id
+ .clone()
+ .unwrap_or_else(|| "no-session".to_string())
+ }
+}
+
#[derive(Debug)]
struct MonitorStore {
started_at: SystemTime,
@@ -227,6 +260,7 @@ impl MonitorHandle {
Ok(store) => store.snapshot(),
Err(_) => MonitorState {
started_at: SystemTime::now(),
+ sessions: Vec::new(),
active: Vec::new(),
recent: Vec::new(),
},
@@ -498,14 +532,91 @@ impl MonitorStore {
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);
MonitorState {
started_at: self.started_at,
+ sessions,
active,
recent: self.recent.iter().cloned().collect(),
}
}
}
+fn session_summaries(
+ active: &[ActiveRequest],
+ recent: &VecDeque<CompletedRequest>,
+) -> Vec<SessionSummary> {
+ let mut sessions: HashMap<Option<String>, SessionSummary> = HashMap::new();
+ for request in recent.iter().rev() {
+ let entry = sessions
+ .entry(request.session_id.clone())
+ .or_insert_with(|| SessionSummary {
+ session_id: request.session_id.clone(),
+ active_count: 0,
+ request_count: 0,
+ failure_count: 0,
+ provider: None,
+ model: None,
+ last_seen: request.finished_at,
+ input_tokens: 0,
+ output_tokens: 0,
+ elapsed: Duration::ZERO,
+ last_status: "-".to_string(),
+ });
+ entry.request_count += 1;
+ if request.status == RequestStatus::Failed {
+ entry.failure_count += 1;
+ }
+ entry.provider = request.provider.clone().or(entry.provider.clone());
+ entry.model = request.model.clone().or(entry.model.clone());
+ entry.last_seen = request.finished_at;
+ entry.input_tokens = entry
+ .input_tokens
+ .saturating_add(request.input_tokens.unwrap_or(0));
+ entry.output_tokens = entry
+ .output_tokens
+ .saturating_add(request.output_tokens.unwrap_or(0));
+ entry.elapsed = entry.elapsed.saturating_add(request.latency);
+ entry.last_status = request.status.label().to_string();
+ }
+
+ for request in active {
+ let entry = sessions
+ .entry(request.session_id.clone())
+ .or_insert_with(|| SessionSummary {
+ session_id: request.session_id.clone(),
+ active_count: 0,
+ request_count: 0,
+ failure_count: 0,
+ provider: None,
+ model: None,
+ last_seen: request.started_at,
+ input_tokens: 0,
+ output_tokens: 0,
+ elapsed: Duration::ZERO,
+ last_status: "-".to_string(),
+ });
+ entry.active_count += 1;
+ entry.request_count += 1;
+ entry.provider = request.provider.clone().or(entry.provider.clone());
+ entry.model = request.model.clone().or(entry.model.clone());
+ entry.last_seen = SystemTime::now();
+ entry.input_tokens = entry
+ .input_tokens
+ .saturating_add(request.input_tokens.unwrap_or(0));
+ entry.output_tokens = entry
+ .output_tokens
+ .saturating_add(request.output_tokens.unwrap_or(0));
+ entry.elapsed = entry.elapsed.saturating_add(request.elapsed());
+ entry.last_status = request.status.label().to_string();
+ }
+
+ let mut out: Vec<_> = sessions.into_values().collect();
+ out.sort_by_key(|session| session.last_seen);
+ out.reverse();
+ out
+}
+
pub fn throughput(
output_tokens: Option<u64>,
streamed_bytes: u64,
@@ -528,6 +639,36 @@ pub fn throughput(
Throughput::None
}
+pub fn usage_from_anthropic_sse(bytes: &[u8]) -> (Option<u64>, Option<u64>) {
+ let text = String::from_utf8_lossy(bytes);
+ let mut input_tokens = None;
+ let mut output_tokens = None;
+ for line in text.lines() {
+ let Some(data) = line.strip_prefix("data:") else {
+ continue;
+ };
+ let Ok(value) = serde_json::from_str::<serde_json::Value>(data.trim()) else {
+ continue;
+ };
+ for usage in [
+ value.pointer("/usage"),
+ value.pointer("/delta/usage"),
+ value.pointer("/message/usage"),
+ ]
+ .into_iter()
+ .flatten()
+ {
+ if let Some(tokens) = usage.get("input_tokens").and_then(|value| value.as_u64()) {
+ input_tokens = Some(tokens);
+ }
+ if let Some(tokens) = usage.get("output_tokens").and_then(|value| value.as_u64()) {
+ output_tokens = Some(tokens);
+ }
+ }
+ }
+ (input_tokens, output_tokens)
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -604,4 +745,42 @@ mod tests {
Throughput::EventsPerSecond(18.0)
);
}
+
+ #[test]
+ fn sse_usage_extracts_final_message_delta_tokens() {
+ let sse = br#"event: message_start
+data: {"type":"message_start","message":{"usage":{"input_tokens":0,"output_tokens":0}}}
+
+event: message_delta
+data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":12,"output_tokens":48}}
+
+"#;
+ assert_eq!(usage_from_anthropic_sse(sse), (Some(12), Some(48)));
+ }
+
+ #[test]
+ fn session_summaries_group_recent_and_active_requests() {
+ let monitor = MonitorHandle::new(10);
+ monitor.request_started(
+ "r1",
+ Some("s1".to_string()),
+ Some(1),
+ EndpointKind::Messages,
+ );
+ monitor.provider_selected("r1", "codex", "gpt-5.5");
+ monitor.request_completed("r1", 200, Some(10), Some(20));
+ monitor.request_started(
+ "r2",
+ Some("s1".to_string()),
+ Some(2),
+ EndpointKind::Messages,
+ );
+ monitor.provider_selected("r2", "codex", "gpt-5.5");
+ let state = monitor.snapshot();
+ assert_eq!(state.sessions.len(), 1);
+ assert_eq!(state.sessions[0].label(), "s1");
+ assert_eq!(state.sessions[0].request_count, 2);
+ assert_eq!(state.sessions[0].active_count, 1);
+ assert_eq!(state.sessions[0].output_tokens, 20);
+ }
}
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index 6de94f3..7171e12 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -15,6 +15,7 @@ use std::sync::Arc;
use crate::anthropic::error::json_error;
use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};
use crate::config;
+use crate::monitor::usage_from_anthropic_sse;
use crate::provider::{CliHandlers, Provider, RequestContext};
use crate::registry;
@@ -148,12 +149,13 @@ impl Provider for CodexProvider {
}
};
if let Some(monitor) = ctx.monitor.as_ref() {
+ let (input_tokens, output_tokens) = usage_from_anthropic_sse(&sse_bytes);
monitor.stream_progress(
&ctx.req_id,
sse_bytes.len() as u64,
count_sse_events(&sse_bytes),
- None,
- None,
+ input_tokens,
+ output_tokens,
);
}
update_continuation_from_upstream(
diff --git a/src/providers/cursor/mod.rs b/src/providers/cursor/mod.rs
index 91581da..90551e9 100644
--- a/src/providers/cursor/mod.rs
+++ b/src/providers/cursor/mod.rs
@@ -18,6 +18,7 @@ use http::StatusCode;
use crate::anthropic::error::json_error;
use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};
+use crate::monitor::usage_from_anthropic_sse;
use crate::provider::{CliHandlers, Provider, RequestContext};
use crate::providers::cursor::auth::load_cursor_token;
use crate::providers::cursor::client::CursorHttpClient;
@@ -81,12 +82,13 @@ impl Provider for CursorProvider {
let (_result_messages, sse_bytes) =
resume_cursor_tool_bridge(session_id, &message_id, model, result, &pending);
if let Some(monitor) = ctx.monitor.as_ref() {
+ let (input_tokens, output_tokens) = usage_from_anthropic_sse(&sse_bytes);
monitor.stream_progress(
&ctx.req_id,
sse_bytes.len() as u64,
count_sse_events(&sse_bytes),
- None,
- None,
+ input_tokens,
+ output_tokens,
);
}
let headers = [
@@ -150,12 +152,13 @@ impl Provider for CursorProvider {
Box::new(|| uuid::Uuid::new_v4().to_string().replace('-', "")),
);
if let Some(monitor) = ctx.monitor.as_ref() {
+ let (input_tokens, output_tokens) = usage_from_anthropic_sse(&sse_bytes);
monitor.stream_progress(
&ctx.req_id,
sse_bytes.len() as u64,
count_sse_events(&sse_bytes),
- None,
- None,
+ input_tokens,
+ output_tokens,
);
}
@@ -168,12 +171,13 @@ impl Provider for CursorProvider {
} else {
let sse_bytes = sse::frame_cursor_stream(&upstream, &message_id, model);
if let Some(monitor) = ctx.monitor.as_ref() {
+ let (input_tokens, output_tokens) = usage_from_anthropic_sse(&sse_bytes);
monitor.stream_progress(
&ctx.req_id,
sse_bytes.len() as u64,
count_sse_events(&sse_bytes),
- None,
- None,
+ input_tokens,
+ output_tokens,
);
}
let headers = [
diff --git a/src/providers/kimi/mod.rs b/src/providers/kimi/mod.rs
index 592eb1d..7353369 100644
--- a/src/providers/kimi/mod.rs
+++ b/src/providers/kimi/mod.rs
@@ -11,6 +11,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
use crate::anthropic::error::json_error;
use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};
+use crate::monitor::usage_from_anthropic_sse;
use crate::provider::{CliHandlers, Provider, RequestContext};
use crate::providers::kimi::auth::token_store::file_store;
use crate::providers::kimi::translate::accumulate::accumulate_response;
@@ -125,12 +126,13 @@ impl Provider for KimiProvider {
}
};
if let Some(monitor) = ctx.monitor.as_ref() {
+ let (input_tokens, output_tokens) = usage_from_anthropic_sse(&sse_bytes);
monitor.stream_progress(
&ctx.req_id,
sse_bytes.len() as u64,
count_sse_events(&sse_bytes),
- None,
- None,
+ input_tokens,
+ output_tokens,
);
}
diff --git a/src/tui.rs b/src/tui.rs
index 3a24f8b..8bc5a60 100644
--- a/src/tui.rs
+++ b/src/tui.rs
@@ -19,7 +19,7 @@ use ratatui::{
use tokio::sync::oneshot;
use crate::{
- monitor::{ActiveRequest, CompletedRequest, MonitorHandle, MonitorState},
+ monitor::{ActiveRequest, CompletedRequest, MonitorHandle, MonitorState, SessionSummary},
paths,
registry::Registry,
};
@@ -127,8 +127,9 @@ fn render(frame: &mut ratatui::Frame<'_>, app: &mut MonitorApp, state: &MonitorS
} else {
Constraint::Length(0)
},
- Constraint::Percentage(38),
- Constraint::Percentage(38),
+ Constraint::Percentage(40),
+ Constraint::Percentage(25),
+ Constraint::Percentage(35),
Constraint::Length(if app.show_help { 5 } else { 3 }),
])
.split(frame.area());
@@ -143,12 +144,13 @@ fn render(frame: &mut ratatui::Frame<'_>, app: &mut MonitorApp, state: &MonitorS
);
}
if app.detail {
- render_detail(frame, root[2], state, app.selected);
+ render_session_detail(frame, root[2], state, app.selected);
} else {
- render_active(frame, root[2], &state.active);
+ render_sessions(frame, root[2], &state.sessions, app.selected);
}
- render_recent(frame, root[3], &state.recent);
- render_footer(frame, root[4], app);
+ render_active(frame, root[3], &state.active);
+ render_recent(frame, root[4], &state.recent);
+ render_footer(frame, root[5], app);
}
fn render_header(
@@ -167,9 +169,10 @@ fn render_header(
Style::default().add_modifier(Modifier::BOLD),
),
Span::raw(format!(
- " http://127.0.0.1:{} uptime {} active {}",
+ " http://127.0.0.1:{} uptime {} sessions {} active {}",
app.port,
format_duration(uptime),
+ state.sessions.len(),
state.active.len()
)),
]);
@@ -179,6 +182,52 @@ fn render_header(
);
}
+fn render_sessions(
+ frame: &mut ratatui::Frame<'_>,
+ area: Rect,
+ sessions: &[SessionSummary],
+ selected: usize,
+) {
+ let rows = sessions.iter().enumerate().map(|(index, session)| {
+ let marker = if index == selected { ">" } else { " " };
+ Row::new(vec![
+ Cell::from(marker),
+ Cell::from(shorten(&session.label(), 26)),
+ Cell::from(session.active_count.to_string()),
+ Cell::from(session.request_count.to_string()),
+ Cell::from(session.failure_count.to_string()),
+ Cell::from(session.provider.as_deref().unwrap_or("-")),
+ Cell::from(session.model.as_deref().unwrap_or("-")),
+ Cell::from(format!(
+ "{}/{}",
+ session.input_tokens, session.output_tokens
+ )),
+ Cell::from(session.rate().label()),
+ Cell::from(session.last_status.as_str()),
+ ])
+ });
+ let table = Table::new(
+ rows,
+ [
+ Constraint::Length(1),
+ Constraint::Percentage(24),
+ Constraint::Length(6),
+ Constraint::Length(5),
+ Constraint::Length(5),
+ Constraint::Length(10),
+ Constraint::Percentage(20),
+ Constraint::Length(13),
+ Constraint::Length(12),
+ Constraint::Length(10),
+ ],
+ )
+ .header(Row::new([
+ "", "session", "active", "reqs", "fail", "provider", "model", "tokens", "rate", "status",
+ ]))
+ .block(Block::default().title("Sessions").borders(Borders::ALL));
+ frame.render_widget(table, area);
+}
+
fn render_active(frame: &mut ratatui::Frame<'_>, area: Rect, active: &[ActiveRequest]) {
let rows = active.iter().map(|request| {
Row::new(vec![
@@ -233,6 +282,7 @@ fn render_recent(frame: &mut ratatui::Frame<'_>, area: Rect, recent: &[Completed
Cell::from(request.provider.as_deref().unwrap_or("-")),
Cell::from(request.model.as_deref().unwrap_or("-")),
Cell::from(format_duration(request.latency)),
+ Cell::from(request.rate().label()),
Cell::from(tokens),
Cell::from(request.error.as_deref().unwrap_or("")),
])
@@ -243,14 +293,15 @@ fn render_recent(frame: &mut ratatui::Frame<'_>, area: Rect, recent: &[Completed
Constraint::Length(8),
Constraint::Length(6),
Constraint::Length(10),
- Constraint::Percentage(24),
+ Constraint::Percentage(20),
Constraint::Length(9),
+ Constraint::Length(12),
Constraint::Length(11),
- Constraint::Percentage(30),
+ Constraint::Percentage(24),
],
)
.header(Row::new([
- "finished", "status", "provider", "model", "latency", "tokens", "error",
+ "finished", "status", "provider", "model", "latency", "rate", "tokens", "error",
]))
.block(
Block::default()
@@ -260,53 +311,40 @@ fn render_recent(frame: &mut ratatui::Frame<'_>, area: Rect, recent: &[Completed
frame.render_widget(table, area);
}
-fn render_detail(
+fn render_session_detail(
frame: &mut ratatui::Frame<'_>,
area: Rect,
state: &MonitorState,
selected: usize,
) {
- let lines = if let Some(request) = state.active.get(selected) {
+ let lines = if let Some(session) = state.sessions.get(selected) {
vec![
- Line::from(format!("request: {}", request.request_id)),
- Line::from(format!(
- "session: {}",
- session_label(request.session_id.as_deref(), request.session_seq)
- )),
+ Line::from(format!("session: {}", session.label())),
+ Line::from(format!("active requests: {}", session.active_count)),
+ Line::from(format!("total requests: {}", session.request_count)),
+ Line::from(format!("failures: {}", session.failure_count)),
Line::from(format!(
"provider: {}",
- request.provider.as_deref().unwrap_or("-")
+ session.provider.as_deref().unwrap_or("-")
)),
Line::from(format!(
"model: {}",
- request.model.as_deref().unwrap_or("-")
- )),
- Line::from(format!("status: {}", request.status.label())),
- Line::from(format!(
- "stream: {} bytes, {} events",
- request.streamed_bytes, request.stream_chunks
- )),
- Line::from(format!("rate: {}", request.rate().label())),
- Line::from(format!(
- "traffic: {}",
- request
- .traffic_capture_path
- .as_ref()
- .map(|path| path.display().to_string())
- .unwrap_or_else(|| "-".to_string())
+ session.model.as_deref().unwrap_or("-")
)),
Line::from(format!(
- "error: {}",
- request.error.as_deref().unwrap_or("-")
+ "tokens: {}/{}",
+ session.input_tokens, session.output_tokens
)),
+ Line::from(format!("rate: {}", session.rate().label())),
+ Line::from(format!("last status: {}", session.last_status)),
]
} else {
- vec![Line::from("No active request selected")]
+ vec![Line::from("No session selected")]
};
frame.render_widget(
Paragraph::new(lines).block(
Block::default()
- .title("Request detail")
+ .title("Session detail")
.borders(Borders::ALL),
),
area,
@@ -315,9 +353,9 @@ fn render_detail(
fn render_footer(frame: &mut ratatui::Frame<'_>, area: Rect, app: &MonitorApp) {
let hints = if app.show_help {
- "q/Ctrl-C quit ? help b setup j/Down next k/Up previous Enter detail Esc back"
+ "q/Ctrl-C quit ? help b setup j/Down next k/Up previous Enter session detail Esc back"
} else {
- "q quit ? help b setup Enter detail"
+ "q quit ? help b setup Enter session"
};
frame.render_widget(
Paragraph::new(hints).block(Block::default().borders(Borders::ALL)),
@@ -372,11 +410,11 @@ fn format_system_time(time: SystemTime) -> String {
)
}
-fn session_label(session_id: Option<&str>, session_seq: Option<u64>) -> String {
- match (session_id, session_seq) {
- (Some(id), Some(seq)) => format!("{id} #{seq}"),
- (Some(id), None) => id.to_string(),
- (None, Some(seq)) => format!("#{seq}"),
- (None, None) => "-".to_string(),
+fn shorten(value: &str, max_chars: usize) -> String {
+ if value.chars().count() <= max_chars {
+ return value.to_string();
}
+ let mut out: String = value.chars().take(max_chars.saturating_sub(1)).collect();
+ out.push('~');
+ out
}