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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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: &[CompletedCell::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: &[CompletedConstraint::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: &[Completedframe.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}