Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
add ratatui proxy monitor
Raine Virta66f9a4845c8f
diff --git a/Cargo.lock b/Cargo.lockindex 8c69f00..52d1573 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -17,6 +17,12 @@ dependencies = ["memchr",]+[[package]]+name = "allocator-api2"+version = "0.2.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"+[[package]]name = "anstream"version = "1.0.0"@@ -225,6 +231,21 @@ version = "1.12.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "8ae3f5d315924270530207e2a68396c3cc547f6dca3fbdca317cfb1a51edb593"+[[package]]+name = "cassowary"+version = "0.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"++[[package]]+name = "castaway"+version = "0.2.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"+dependencies = [+ "rustversion",+]+[[package]]name = "cc"version = "1.2.65"@@ -298,6 +319,7 @@ dependencies = ["base64","bytes","clap",+ "crossterm","flate2","futures-core","futures-util",@@ -309,6 +331,7 @@ dependencies = ["predicates","prost","rand 0.8.6",+ "ratatui","regex-lite","reqwest","serde",@@ -332,6 +355,20 @@ version = "1.0.5"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"+[[package]]+name = "compact_str"+version = "0.8.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7fd622ebbb56a5b2ccb651b32b911cdeb2a9b4b11776b2473bf26a26a286244e"+dependencies = [+ "castaway",+ "cfg-if",+ "itoa",+ "rustversion",+ "ryu",+ "static_assertions",+]+[[package]]name = "core-foundation"version = "0.10.1"@@ -366,6 +403,31 @@ dependencies = ["cfg-if",]+[[package]]+name = "crossterm"+version = "0.28.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"+dependencies = [+ "bitflags",+ "crossterm_winapi",+ "mio",+ "parking_lot",+ "rustix 0.38.44",+ "signal-hook",+ "signal-hook-mio",+ "winapi",+]++[[package]]+name = "crossterm_winapi"+version = "0.9.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"+dependencies = [+ "winapi",+]+[[package]]name = "crypto-common"version = "0.1.7"@@ -376,6 +438,40 @@ dependencies = ["typenum",]+[[package]]+name = "darling"+version = "0.23.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"+dependencies = [+ "darling_core",+ "darling_macro",+]++[[package]]+name = "darling_core"+version = "0.23.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"+dependencies = [+ "ident_case",+ "proc-macro2",+ "quote",+ "strsim",+ "syn",+]++[[package]]+name = "darling_macro"+version = "0.23.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"+dependencies = [+ "darling_core",+ "quote",+ "syn",+]+[[package]]name = "data-encoding"version = "2.11.0"@@ -474,6 +570,12 @@ version = "1.0.7"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"+[[package]]+name = "foldhash"+version = "0.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"+[[package]]name = "form_urlencoded"version = "1.2.2"@@ -611,6 +713,17 @@ dependencies = ["tracing",]+[[package]]+name = "hashbrown"+version = "0.15.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"+dependencies = [+ "allocator-api2",+ "equivalent",+ "foldhash",+]+[[package]]name = "hashbrown"version = "0.17.1"@@ -828,6 +941,12 @@ dependencies = ["zerovec",]+[[package]]+name = "ident_case"+version = "1.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"+[[package]]name = "idna"version = "1.1.0"@@ -856,7 +975,29 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"dependencies = ["equivalent",- "hashbrown",+ "hashbrown 0.17.1",+]++[[package]]+name = "indoc"+version = "2.0.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"+dependencies = [+ "rustversion",+]++[[package]]+name = "instability"+version = "0.3.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5eb2d60ef19920a3a9193c3e371f726ec1dafc045dac788d0fb3704272458971"+dependencies = [+ "darling",+ "indoc",+ "proc-macro2",+ "quote",+ "syn",][[package]]@@ -871,6 +1012,15 @@ version = "1.70.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"+[[package]]+name = "itertools"+version = "0.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"+dependencies = [+ "either",+]+[[package]]name = "itertools"version = "0.14.0"@@ -909,6 +1059,12 @@ version = "0.2.186"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"+[[package]]+name = "linux-raw-sys"+version = "0.4.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"+[[package]]name = "linux-raw-sys"version = "0.12.1"@@ -921,12 +1077,30 @@ version = "0.8.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"+[[package]]+name = "lock_api"+version = "0.4.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"+dependencies = [+ "scopeguard",+]+[[package]]name = "log"version = "0.4.33"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"+[[package]]+name = "lru"+version = "0.12.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38"+dependencies = [+ "hashbrown 0.15.5",+]+[[package]]name = "lru-slab"version = "0.1.2"@@ -977,6 +1151,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda"dependencies = ["libc",+ "log","wasi","windows-sys 0.61.2",]@@ -1029,6 +1204,35 @@ version = "0.2.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"+[[package]]+name = "parking_lot"+version = "0.12.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"+dependencies = [+ "lock_api",+ "parking_lot_core",+]++[[package]]+name = "parking_lot_core"+version = "0.9.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"+dependencies = [+ "cfg-if",+ "libc",+ "redox_syscall",+ "smallvec",+ "windows-link",+]++[[package]]+name = "paste"+version = "1.0.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"+[[package]]name = "percent-encoding"version = "2.3.2"@@ -1121,7 +1325,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"dependencies = ["anyhow",- "itertools",+ "itertools 0.14.0","proc-macro2","quote","syn",@@ -1262,6 +1466,36 @@ dependencies = ["getrandom 0.3.4",]+[[package]]+name = "ratatui"+version = "0.29.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "eabd94c2f37801c20583fc49dd5cd6b0ba68c716787c2dd6ed18571e1e63117b"+dependencies = [+ "bitflags",+ "cassowary",+ "compact_str",+ "crossterm",+ "indoc",+ "instability",+ "itertools 0.13.0",+ "lru",+ "paste",+ "strum",+ "unicode-segmentation",+ "unicode-truncate",+ "unicode-width 0.2.0",+]++[[package]]+name = "redox_syscall"+version = "0.5.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"+dependencies = [+ "bitflags",+]+[[package]]name = "regex"version = "1.12.4"@@ -1360,6 +1594,19 @@ version = "2.1.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"+[[package]]+name = "rustix"+version = "0.38.44"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"+dependencies = [+ "bitflags",+ "errno",+ "libc",+ "linux-raw-sys 0.4.15",+ "windows-sys 0.52.0",+]+[[package]]name = "rustix"version = "1.1.4"@@ -1369,7 +1616,7 @@ dependencies = ["bitflags","errno","libc",- "linux-raw-sys",+ "linux-raw-sys 0.12.1","windows-sys 0.61.2",]@@ -1441,6 +1688,12 @@ dependencies = ["windows-sys 0.61.2",]+[[package]]+name = "scopeguard"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"+[[package]]name = "security-framework"version = "3.7.0"@@ -1567,6 +1820,27 @@ version = "2.0.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"+[[package]]+name = "signal-hook"+version = "0.3.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"+dependencies = [+ "libc",+ "signal-hook-registry",+]++[[package]]+name = "signal-hook-mio"+version = "0.2.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"+dependencies = [+ "libc",+ "mio",+ "signal-hook",+]+[[package]]name = "signal-hook-registry"version = "1.4.8"@@ -1611,12 +1885,40 @@ version = "1.2.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"+[[package]]+name = "static_assertions"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"+[[package]]name = "strsim"version = "0.11.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"+[[package]]+name = "strum"+version = "0.26.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"+dependencies = [+ "strum_macros",+]++[[package]]+name = "strum_macros"+version = "0.26.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"+dependencies = [+ "heck",+ "proc-macro2",+ "quote",+ "rustversion",+ "syn",+]+[[package]]name = "subtle"version = "2.6.1"@@ -1663,7 +1965,7 @@ dependencies = ["fastrand","getrandom 0.4.3","once_cell",- "rustix",+ "rustix 1.1.4","windows-sys 0.61.2",]@@ -2002,6 +2304,35 @@ version = "1.0.24"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"+[[package]]+name = "unicode-segmentation"+version = "1.13.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"++[[package]]+name = "unicode-truncate"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b3644627a5af5fa321c95b9b235a72fd24cd29c648c2c379431e6628655627bf"+dependencies = [+ "itertools 0.13.0",+ "unicode-segmentation",+ "unicode-width 0.1.14",+]++[[package]]+name = "unicode-width"+version = "0.1.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"++[[package]]+name = "unicode-width"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"+[[package]]name = "untrusted"version = "0.9.0"@@ -2192,6 +2523,28 @@ dependencies = ["rustls-pki-types",]+[[package]]+name = "winapi"+version = "0.3.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"+dependencies = [+ "winapi-i686-pc-windows-gnu",+ "winapi-x86_64-pc-windows-gnu",+]++[[package]]+name = "winapi-i686-pc-windows-gnu"+version = "0.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"++[[package]]+name = "winapi-x86_64-pc-windows-gnu"+version = "0.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"+[[package]]name = "windows-link"version = "0.2.1"diff --git a/Cargo.toml b/Cargo.tomlindex 11b994d..d7751c6 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -36,6 +36,8 @@ tokio-tungstenite = { version = "0.24", default-features = false, features = ["curl = "2"prost = "0.13"flate2 = "1.0"+ratatui = "0.29"+crossterm = "0.28"[dev-dependencies]tempfile = "3.14"diff --git a/src/lib.rs b/src/lib.rsindex 84f3e2f..4295089 100644--- a/src/lib.rs+++ b/src/lib.rs@@ -2,6 +2,7 @@ pub mod anthropic;pub mod auth;pub mod config;pub mod logging;+pub mod monitor;pub mod paths;pub mod provider;pub mod providers;@@ -10,6 +11,7 @@ pub mod retry;pub mod server;pub mod session;pub mod traffic;+pub mod tui;pub use crate::anthropic::error::{ErrorDetail, ErrorEnvelope, json_error};pub use crate::anthropic::schema::MessagesRequest;diff --git a/src/main.rs b/src/main.rsindex 80c3e2c..2ecaa3a 100644--- a/src/main.rs+++ b/src/main.rs@@ -1,10 +1,14 @@use anyhow::Result;use clap::{ArgAction, Parser, Subcommand};use claude_code_proxy::{- config, paths,+ config,+ monitor::MonitorHandle,+ paths,registry::{ANTHROPIC_STYLE_ALIASES, Registry},server::{self, ServerConfig},+ tui::{self, MonitorUiConfig},};+use std::io::IsTerminal;const VERSION: &str = env!("CARGO_PKG_VERSION");@@ -29,6 +33,8 @@ enum Commands {Serve {#[arg(long)]port: Option<u16>,+ #[arg(long = "no-monitor", action = ArgAction::SetTrue)]+ no_monitor: bool,},Models {#[arg(long)]@@ -64,24 +70,58 @@ fn main() -> Result<()> {return Ok(());}- let commands = cli.command.unwrap_or(Commands::Serve { port: None });+ let commands = cli.command.unwrap_or(Commands::Serve {+ port: None,+ no_monitor: false,+ });match commands {Commands::Version => {println!("claude-code-proxy {}", VERSION);Ok(())}- Commands::Serve { port } => {+ Commands::Serve { port, no_monitor } => {let effective_port = port.unwrap_or_else(config::port);let registry = Registry::with_default_alias();- print_server_banner(effective_port, ®istry);- tokio::runtime::Builder::new_multi_thread()+ let runtime = tokio::runtime::Builder::new_multi_thread().enable_all()- .build()?- .block_on(server::serve(ServerConfig {- port: effective_port,- }))- .map_err(|err| anyhow::anyhow!(err))+ .build()?;+ match select_serve_mode(std::io::stdout().is_terminal(), no_monitor) {+ ServeMode::Plain => {+ print_server_banner(effective_port, ®istry);+ runtime+ .block_on(server::serve(ServerConfig {+ port: effective_port,+ monitor: None,+ }))+ .map_err(|err| anyhow::anyhow!(err))+ }+ ServeMode::Monitor => {+ let monitor = MonitorHandle::default();+ let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();+ let listener = runtime+ .block_on(tokio::net::TcpListener::bind(("127.0.0.1", effective_port)))?;+ let server_monitor = monitor.clone();+ let server_task = runtime.spawn(server::serve_listener(+ listener,+ Some(server_monitor),+ async move {+ let _ = shutdown_rx.await;+ },+ ));+ let ui_result = tui::run_monitor(+ monitor,+ MonitorUiConfig {+ port: effective_port,+ registry: ®istry,+ shutdown: Some(shutdown_tx),+ },+ );+ let server_result = runtime.block_on(server_task)?;+ ui_result?;+ server_result.map_err(|err| anyhow::anyhow!(err))+ }+ }}Commands::Models { full } => {print_models(&Registry::with_default_alias(), full);@@ -93,6 +133,20 @@ fn main() -> Result<()> {}}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum ServeMode {+ Monitor,+ Plain,+}++fn select_serve_mode(stdout_is_tty: bool, no_monitor: bool) -> ServeMode {+ if stdout_is_tty && !no_monitor {+ ServeMode::Monitor+ } else {+ ServeMode::Plain+ }+}+fn run_provider_cli(name: &str, command: ProviderGroup) -> Result<()> {let registry = Registry::with_default_alias();let provider = registry@@ -191,3 +245,23 @@ fn print_server_banner(port: u16, registry: &Registry) {fn alias_names() -> usize {ANTHROPIC_STYLE_ALIASES.len()}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn default_serve_selects_monitor_on_tty() {+ assert_eq!(select_serve_mode(true, false), ServeMode::Monitor);+ }++ #[test]+ fn no_monitor_selects_plain_mode() {+ assert_eq!(select_serve_mode(true, true), ServeMode::Plain);+ }++ #[test]+ fn non_tty_stdout_selects_plain_mode() {+ assert_eq!(select_serve_mode(false, false), ServeMode::Plain);+ }+}diff --git a/src/monitor.rs b/src/monitor.rsnew file mode 100644index 0000000..a028018--- /dev/null+++ b/src/monitor.rs@@ -0,0 +1,607 @@+use std::{+ collections::{HashMap, VecDeque},+ path::PathBuf,+ sync::{Arc, Mutex},+ time::{Duration, Instant, SystemTime},+};++const DEFAULT_RECENT_LIMIT: usize = 200;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum EndpointKind {+ Messages,+ CountTokens,+}++impl EndpointKind {+ pub fn label(self) -> &'static str {+ match self {+ Self::Messages => "messages",+ Self::CountTokens => "count_tokens",+ }+ }+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum RequestStatus {+ Started,+ ProviderSelected,+ Upstream,+ Streaming,+ Completed,+ Failed,+}++impl RequestStatus {+ pub fn label(&self) -> &'static str {+ match self {+ Self::Started => "started",+ Self::ProviderSelected => "selected",+ Self::Upstream => "upstream",+ Self::Streaming => "streaming",+ Self::Completed => "completed",+ Self::Failed => "failed",+ }+ }+}++#[derive(Debug, Clone)]+pub enum MonitorEvent {+ RequestStarted {+ request_id: String,+ session_id: Option<String>,+ session_seq: Option<u64>,+ endpoint: EndpointKind,+ },+ ProviderSelected {+ request_id: String,+ provider: String,+ model: String,+ },+ UpstreamStarted {+ request_id: String,+ },+ TrafficCapturePath {+ request_id: String,+ path: PathBuf,+ },+ StreamProgress {+ request_id: String,+ bytes: u64,+ chunks: u64,+ input_tokens: Option<u64>,+ output_tokens: Option<u64>,+ },+ UsageUpdated {+ request_id: String,+ input_tokens: Option<u64>,+ output_tokens: Option<u64>,+ },+ RequestCompleted {+ request_id: String,+ http_status: u16,+ input_tokens: Option<u64>,+ output_tokens: Option<u64>,+ },+ RequestFailed {+ request_id: String,+ http_status: Option<u16>,+ error: String,+ },+}++#[derive(Debug, Clone)]+pub struct ActiveRequest {+ pub request_id: String,+ pub session_id: Option<String>,+ pub session_seq: Option<u64>,+ pub provider: Option<String>,+ pub model: Option<String>,+ pub endpoint: EndpointKind,+ pub started_at: SystemTime,+ started_instant: Instant,+ pub status: RequestStatus,+ pub streamed_bytes: u64,+ pub stream_chunks: u64,+ pub input_tokens: Option<u64>,+ pub output_tokens: Option<u64>,+ pub error: Option<String>,+ pub traffic_capture_path: Option<PathBuf>,+}++impl ActiveRequest {+ pub fn elapsed(&self) -> Duration {+ self.started_instant.elapsed()+ }++ pub fn rate(&self) -> Throughput {+ throughput(+ self.output_tokens,+ self.streamed_bytes,+ self.stream_chunks,+ self.elapsed(),+ )+ }+}++#[derive(Debug, Clone)]+pub struct CompletedRequest {+ pub request_id: String,+ pub session_id: Option<String>,+ pub session_seq: Option<u64>,+ pub provider: Option<String>,+ pub model: Option<String>,+ pub endpoint: EndpointKind,+ pub started_at: SystemTime,+ pub finished_at: SystemTime,+ pub status: RequestStatus,+ pub http_status: Option<u16>,+ pub latency: Duration,+ pub streamed_bytes: u64,+ pub stream_chunks: u64,+ pub input_tokens: Option<u64>,+ pub output_tokens: Option<u64>,+ pub error: Option<String>,+ pub traffic_capture_path: Option<PathBuf>,+}++impl CompletedRequest {+ pub fn rate(&self) -> Throughput {+ throughput(+ self.output_tokens,+ self.streamed_bytes,+ self.stream_chunks,+ self.latency,+ )+ }+}++#[derive(Debug, Clone, PartialEq)]+pub enum Throughput {+ TokensPerSecond(f64),+ BytesPerSecond(f64),+ EventsPerSecond(f64),+ None,+}++impl Throughput {+ pub fn label(&self) -> String {+ match self {+ Self::TokensPerSecond(value) => format!("{value:.1} tok/s"),+ Self::BytesPerSecond(value) if *value >= 1024.0 => {+ format!("{:.1} KB/s", value / 1024.0)+ }+ Self::BytesPerSecond(value) => format!("{value:.0} B/s"),+ Self::EventsPerSecond(value) => format!("{value:.1} ev/s"),+ Self::None => "-".to_string(),+ }+ }+}++#[derive(Debug, Clone)]+pub struct MonitorState {+ pub started_at: SystemTime,+ pub active: Vec<ActiveRequest>,+ pub recent: Vec<CompletedRequest>,+}++#[derive(Debug)]+struct MonitorStore {+ started_at: SystemTime,+ active: HashMap<String, ActiveRequest>,+ recent: VecDeque<CompletedRequest>,+ recent_limit: usize,+}++#[derive(Debug, Clone)]+pub struct MonitorHandle {+ store: Arc<Mutex<MonitorStore>>,+}++impl Default for MonitorHandle {+ fn default() -> Self {+ Self::new(DEFAULT_RECENT_LIMIT)+ }+}++impl MonitorHandle {+ pub fn new(recent_limit: usize) -> Self {+ Self {+ store: Arc::new(Mutex::new(MonitorStore {+ started_at: SystemTime::now(),+ active: HashMap::new(),+ recent: VecDeque::new(),+ recent_limit,+ })),+ }+ }++ pub fn publish(&self, event: MonitorEvent) {+ if let Ok(mut store) = self.store.lock() {+ store.apply(event);+ }+ }++ pub fn snapshot(&self) -> MonitorState {+ match self.store.lock() {+ Ok(store) => store.snapshot(),+ Err(_) => MonitorState {+ started_at: SystemTime::now(),+ active: Vec::new(),+ recent: Vec::new(),+ },+ }+ }++ pub fn request_started(+ &self,+ request_id: impl Into<String>,+ session_id: Option<String>,+ session_seq: Option<u64>,+ endpoint: EndpointKind,+ ) {+ self.publish(MonitorEvent::RequestStarted {+ request_id: request_id.into(),+ session_id,+ session_seq,+ endpoint,+ });+ }++ pub fn provider_selected(+ &self,+ request_id: impl Into<String>,+ provider: impl Into<String>,+ model: impl Into<String>,+ ) {+ self.publish(MonitorEvent::ProviderSelected {+ request_id: request_id.into(),+ provider: provider.into(),+ model: model.into(),+ });+ }++ pub fn upstream_started(&self, request_id: impl Into<String>) {+ self.publish(MonitorEvent::UpstreamStarted {+ request_id: request_id.into(),+ });+ }++ pub fn traffic_capture_path(&self, request_id: impl Into<String>, path: PathBuf) {+ self.publish(MonitorEvent::TrafficCapturePath {+ request_id: request_id.into(),+ path,+ });+ }++ pub fn stream_progress(+ &self,+ request_id: impl Into<String>,+ bytes: u64,+ chunks: u64,+ input_tokens: Option<u64>,+ output_tokens: Option<u64>,+ ) {+ self.publish(MonitorEvent::StreamProgress {+ request_id: request_id.into(),+ bytes,+ chunks,+ input_tokens,+ output_tokens,+ });+ }++ pub fn usage_updated(+ &self,+ request_id: impl Into<String>,+ input_tokens: Option<u64>,+ output_tokens: Option<u64>,+ ) {+ self.publish(MonitorEvent::UsageUpdated {+ request_id: request_id.into(),+ input_tokens,+ output_tokens,+ });+ }++ pub fn request_completed(+ &self,+ request_id: impl Into<String>,+ http_status: u16,+ input_tokens: Option<u64>,+ output_tokens: Option<u64>,+ ) {+ self.publish(MonitorEvent::RequestCompleted {+ request_id: request_id.into(),+ http_status,+ input_tokens,+ output_tokens,+ });+ }++ pub fn request_failed(+ &self,+ request_id: impl Into<String>,+ http_status: Option<u16>,+ error: impl Into<String>,+ ) {+ self.publish(MonitorEvent::RequestFailed {+ request_id: request_id.into(),+ http_status,+ error: error.into(),+ });+ }+}++impl MonitorStore {+ fn apply(&mut self, event: MonitorEvent) {+ match event {+ MonitorEvent::RequestStarted {+ request_id,+ session_id,+ session_seq,+ endpoint,+ } => {+ self.active.insert(+ request_id.clone(),+ ActiveRequest {+ request_id,+ session_id,+ session_seq,+ provider: None,+ model: None,+ endpoint,+ started_at: SystemTime::now(),+ started_instant: Instant::now(),+ status: RequestStatus::Started,+ streamed_bytes: 0,+ stream_chunks: 0,+ input_tokens: None,+ output_tokens: None,+ error: None,+ traffic_capture_path: None,+ },+ );+ }+ MonitorEvent::ProviderSelected {+ request_id,+ provider,+ model,+ } => {+ if let Some(active) = self.active.get_mut(&request_id) {+ active.provider = Some(provider);+ active.model = Some(model);+ active.status = RequestStatus::ProviderSelected;+ }+ }+ MonitorEvent::UpstreamStarted { request_id } => {+ if let Some(active) = self.active.get_mut(&request_id) {+ active.status = RequestStatus::Upstream;+ }+ }+ MonitorEvent::TrafficCapturePath { request_id, path } => {+ if let Some(active) = self.active.get_mut(&request_id) {+ active.traffic_capture_path = Some(path);+ }+ }+ MonitorEvent::StreamProgress {+ request_id,+ bytes,+ chunks,+ input_tokens,+ output_tokens,+ } => {+ if let Some(active) = self.active.get_mut(&request_id) {+ active.status = RequestStatus::Streaming;+ active.streamed_bytes = active.streamed_bytes.saturating_add(bytes);+ active.stream_chunks = active.stream_chunks.saturating_add(chunks);+ active.input_tokens = input_tokens.or(active.input_tokens);+ active.output_tokens = output_tokens.or(active.output_tokens);+ }+ }+ MonitorEvent::UsageUpdated {+ request_id,+ input_tokens,+ output_tokens,+ } => {+ if let Some(active) = self.active.get_mut(&request_id) {+ active.input_tokens = input_tokens.or(active.input_tokens);+ active.output_tokens = output_tokens.or(active.output_tokens);+ }+ }+ MonitorEvent::RequestCompleted {+ request_id,+ http_status,+ input_tokens,+ output_tokens,+ } => {+ self.finish(+ &request_id,+ RequestStatus::Completed,+ Some(http_status),+ input_tokens,+ output_tokens,+ None,+ );+ }+ MonitorEvent::RequestFailed {+ request_id,+ http_status,+ error,+ } => {+ self.finish(+ &request_id,+ RequestStatus::Failed,+ http_status,+ None,+ None,+ Some(error),+ );+ }+ }+ }++ fn finish(+ &mut self,+ request_id: &str,+ status: RequestStatus,+ http_status: Option<u16>,+ input_tokens: Option<u64>,+ output_tokens: Option<u64>,+ error: Option<String>,+ ) {+ let active = self+ .active+ .remove(request_id)+ .unwrap_or_else(|| ActiveRequest {+ request_id: request_id.to_string(),+ session_id: None,+ session_seq: None,+ provider: None,+ model: None,+ endpoint: EndpointKind::Messages,+ started_at: SystemTime::now(),+ started_instant: Instant::now(),+ status: RequestStatus::Started,+ streamed_bytes: 0,+ stream_chunks: 0,+ input_tokens: None,+ output_tokens: None,+ error: None,+ traffic_capture_path: None,+ });+ let completed = CompletedRequest {+ request_id: active.request_id,+ session_id: active.session_id,+ session_seq: active.session_seq,+ provider: active.provider,+ model: active.model,+ endpoint: active.endpoint,+ started_at: active.started_at,+ finished_at: SystemTime::now(),+ status,+ http_status,+ latency: active.started_instant.elapsed(),+ streamed_bytes: active.streamed_bytes,+ stream_chunks: active.stream_chunks,+ input_tokens: input_tokens.or(active.input_tokens),+ output_tokens: output_tokens.or(active.output_tokens),+ error: error.or(active.error),+ traffic_capture_path: active.traffic_capture_path,+ };+ self.recent.push_front(completed);+ while self.recent.len() > self.recent_limit {+ self.recent.pop_back();+ }+ }++ fn snapshot(&self) -> MonitorState {+ let mut active: Vec<_> = self.active.values().cloned().collect();+ active.sort_by_key(|request| request.started_at);+ MonitorState {+ started_at: self.started_at,+ active,+ recent: self.recent.iter().cloned().collect(),+ }+ }+}++pub fn throughput(+ output_tokens: Option<u64>,+ streamed_bytes: u64,+ stream_chunks: u64,+ elapsed: Duration,+) -> Throughput {+ let secs = elapsed.as_secs_f64();+ if secs <= 0.0 {+ return Throughput::None;+ }+ if let Some(tokens) = output_tokens.filter(|tokens| *tokens > 0) {+ return Throughput::TokensPerSecond(tokens as f64 / secs);+ }+ if streamed_bytes > 0 {+ return Throughput::BytesPerSecond(streamed_bytes as f64 / secs);+ }+ if stream_chunks > 0 {+ return Throughput::EventsPerSecond(stream_chunks as f64 / secs);+ }+ Throughput::None+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn started_requests_appear_active() {+ let monitor = MonitorHandle::new(10);+ monitor.request_started(+ "r1",+ Some("s1".to_string()),+ Some(3),+ EndpointKind::Messages,+ );+ let state = monitor.snapshot();+ assert_eq!(state.active.len(), 1);+ assert_eq!(state.active[0].request_id, "r1");+ assert_eq!(state.active[0].session_id.as_deref(), Some("s1"));+ assert_eq!(state.active[0].session_seq, Some(3));+ }++ #[test]+ fn completed_requests_leave_active_and_enter_recent() {+ let monitor = MonitorHandle::new(10);+ monitor.request_started("r1", None, None, EndpointKind::Messages);+ monitor.provider_selected("r1", "codex", "gpt-5.5");+ monitor.request_completed("r1", 200, Some(10), Some(20));+ let state = monitor.snapshot();+ assert!(state.active.is_empty());+ assert_eq!(state.recent.len(), 1);+ assert_eq!(state.recent[0].provider.as_deref(), Some("codex"));+ assert_eq!(state.recent[0].output_tokens, Some(20));+ }++ #[test]+ fn failed_requests_preserve_error_summary() {+ let monitor = MonitorHandle::new(10);+ monitor.request_started("r1", None, None, EndpointKind::Messages);+ monitor.request_failed("r1", Some(400), "Unknown model");+ let state = monitor.snapshot();+ assert_eq!(state.recent[0].status, RequestStatus::Failed);+ assert_eq!(state.recent[0].http_status, Some(400));+ assert_eq!(state.recent[0].error.as_deref(), Some("Unknown model"));+ }++ #[test]+ fn bounded_recent_history_drops_oldest() {+ let monitor = MonitorHandle::new(2);+ for id in ["r1", "r2", "r3"] {+ monitor.request_started(id, None, None, EndpointKind::Messages);+ monitor.request_completed(id, 200, None, None);+ }+ let state = monitor.snapshot();+ let ids: Vec<_> = state+ .recent+ .iter()+ .map(|request| request.request_id.as_str())+ .collect();+ assert_eq!(ids, vec!["r3", "r2"]);+ }++ #[test]+ fn throughput_selects_best_available_signal() {+ let elapsed = Duration::from_secs(2);+ assert_eq!(+ throughput(Some(84), 1024, 10, elapsed),+ Throughput::TokensPerSecond(42.0)+ );+ assert_eq!(+ throughput(None, 2048, 10, elapsed),+ Throughput::BytesPerSecond(1024.0)+ );+ assert_eq!(+ throughput(None, 0, 36, elapsed),+ Throughput::EventsPerSecond(18.0)+ );+ }+}diff --git a/src/provider.rs b/src/provider.rsindex 4b8a939..07c49fc 100644--- a/src/provider.rs+++ b/src/provider.rs@@ -1,4 +1,5 @@use crate::anthropic::schema::MessagesRequest;+use crate::monitor::MonitorHandle;use crate::traffic::TrafficCapture;use anyhow::Result;use async_trait::async_trait;@@ -37,4 +38,5 @@ pub struct RequestContext {pub session_seq: Option<u64>,pub provider: String,pub traffic: Option<Arc<TrafficCapture>>,+ pub monitor: Option<MonitorHandle>,}diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex d45caa5..b21247c 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -764,6 +764,7 @@ mod tests {session_seq: None,provider: "codex".into(),traffic: None,+ monitor: None,};let headers = build_codex_headers(&auth, &ctx).unwrap();assert_eq!(@@ -787,6 +788,7 @@ mod tests {session_seq: None,provider: "codex".into(),traffic: None,+ monitor: None,};let headers = build_codex_headers(&auth, &ctx).unwrap();assert!(headers.get("session_id").is_none());@@ -807,6 +809,7 @@ mod tests {session_seq: None,provider: "codex".into(),traffic: None,+ monitor: None,};let err = build_codex_headers(&auth, &ctx).unwrap_err();assert_eq!(err.status, 500);@@ -860,6 +863,7 @@ mod tests {session_seq: None,provider: "codex".into(),traffic: None,+ monitor: None,};let disabled = super::super::continuation::ContinuationCandidate {previous_response_id: None,@@ -928,6 +932,7 @@ mod tests {session_seq: None,provider: "codex".into(),traffic: None,+ monitor: None,};let result = build_codex_headers(&auth, &ctx);assert!(diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 0a0db80..6de94f3 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -116,6 +116,9 @@ impl Provider for CodexProvider {// Post to upstream with continuationlet client = Arc::new(CodexHttpClient::new());+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.upstream_started(&ctx.req_id);+ }let upstream = match client.post_codex(&translated, &ctx, Some(&continuation)).await@@ -144,6 +147,15 @@ impl Provider for CodexProvider {);}};+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.stream_progress(+ &ctx.req_id,+ sse_bytes.len() as u64,+ count_sse_events(&sse_bytes),+ None,+ None,+ );+ }update_continuation_from_upstream(ctx.session_id.as_deref(),&translated,@@ -164,6 +176,14 @@ impl Provider for CodexProvider {ctx.traffic.as_deref(),) {Ok(json) => {+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.usage_updated(+ &ctx.req_id,+ json.pointer("/usage/input_tokens").and_then(|v| v.as_u64()),+ json.pointer("/usage/output_tokens")+ .and_then(|v| v.as_u64()),+ );+ }update_continuation_from_upstream(ctx.session_id.as_deref(),&translated,@@ -183,7 +203,7 @@ impl Provider for CodexProvider {}}- async fn handle_count_tokens(&self, body: MessagesRequest, _ctx: RequestContext) -> Response {+ async fn handle_count_tokens(&self, body: MessagesRequest, ctx: RequestContext) -> Response {let model = body.model.as_deref().unwrap_or("gpt-5.5");let resolved = resolve_model_request(model);if let Err(e) = assert_allowed_model(&resolved.model) {@@ -215,6 +235,9 @@ impl Provider for CodexProvider {};let tokens = count_translated_tokens(&translated);+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.usage_updated(&ctx.req_id, Some(tokens), None);+ }(StatusCode::OK,Json(CountTokensResponse {@@ -225,6 +248,10 @@ impl Provider for CodexProvider {}}+fn count_sse_events(bytes: &[u8]) -> u64 {+ String::from_utf8_lossy(bytes).matches("event:").count() as u64+}+fn update_continuation_from_upstream(session_id: Option<&str>,request_body: &translate::request::ResponsesRequest,diff --git a/src/providers/cursor/mod.rs b/src/providers/cursor/mod.rsindex 9d2d0d0..91581da 100644--- a/src/providers/cursor/mod.rs+++ b/src/providers/cursor/mod.rs@@ -80,6 +80,15 @@ impl Provider for CursorProvider {if let Some(result) = find_tool_result(&body, pending.tool_use_id()) {let (_result_messages, sse_bytes) =resume_cursor_tool_bridge(session_id, &message_id, model, result, &pending);+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.stream_progress(+ &ctx.req_id,+ sse_bytes.len() as u64,+ count_sse_events(&sse_bytes),+ None,+ None,+ );+ }let headers = [(http::header::CONTENT_TYPE, "text/event-stream"),(http::header::CACHE_CONTROL, "no-cache"),@@ -105,6 +114,9 @@ impl Provider for CursorProvider {let images = request::cursor_selected_images(&body);let client = CursorHttpClient::new();+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.upstream_started(&ctx.req_id);+ }let upstream = match client.run_agent(&token, &prompt, &model, &images).await {Ok(r) => r,Err(e) => {@@ -137,6 +149,15 @@ impl Provider for CursorProvider {allowed,Box::new(|| uuid::Uuid::new_v4().to_string().replace('-', "")),);+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.stream_progress(+ &ctx.req_id,+ sse_bytes.len() as u64,+ count_sse_events(&sse_bytes),+ None,+ None,+ );+ }let headers = [(http::header::CONTENT_TYPE, "text/event-stream"),@@ -146,6 +167,15 @@ impl Provider for CursorProvider {(headers, sse_bytes).into_response()} else {let sse_bytes = sse::frame_cursor_stream(&upstream, &message_id, model);+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.stream_progress(+ &ctx.req_id,+ sse_bytes.len() as u64,+ count_sse_events(&sse_bytes),+ None,+ None,+ );+ }let headers = [(http::header::CONTENT_TYPE, "text/event-stream"),(http::header::CACHE_CONTROL, "no-cache"),@@ -155,7 +185,17 @@ impl Provider for CursorProvider {}} else {match decode_cursor_upstream(&upstream, &message_id, model) {- Ok(json) => (StatusCode::OK, Json(json)).into_response(),+ Ok(json) => {+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.usage_updated(+ &ctx.req_id,+ json.pointer("/usage/input_tokens").and_then(|v| v.as_u64()),+ json.pointer("/usage/output_tokens")+ .and_then(|v| v.as_u64()),+ );+ }+ (StatusCode::OK, Json(json)).into_response()+ }Err(e) => json_error(StatusCode::BAD_GATEWAY,"api_error",@@ -165,9 +205,12 @@ impl Provider for CursorProvider {}}- async fn handle_count_tokens(&self, body: MessagesRequest, _ctx: RequestContext) -> Response {+ async fn handle_count_tokens(&self, body: MessagesRequest, ctx: RequestContext) -> Response {let prompt = render_cursor_prompt(&body);let tokens = (prompt.len() / 4) as u64; // rough estimate+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.usage_updated(&ctx.req_id, Some(tokens), None);+ }(StatusCode::OK,Json(CountTokensResponse {@@ -178,6 +221,10 @@ impl Provider for CursorProvider {}}+fn count_sse_events(bytes: &[u8]) -> u64 {+ String::from_utf8_lossy(bytes).matches("event:").count() as u64+}+// ---------------------------------------------------------------------------// Error mapping// ---------------------------------------------------------------------------diff --git a/src/providers/kimi/mod.rs b/src/providers/kimi/mod.rsindex 68409ab..592eb1d 100644--- a/src/providers/kimi/mod.rs+++ b/src/providers/kimi/mod.rs@@ -89,6 +89,9 @@ impl Provider for KimiProvider {// KimiHttpClient uses a blocking client whose lifecycle belongs on a// blocking thread.+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.upstream_started(&ctx.req_id);+ }let upstream = match tokio::task::spawn_blocking(move || {let client = client::KimiHttpClient::new();let result = client.post_kimi(&translated);@@ -121,6 +124,15 @@ impl Provider for KimiProvider {);}};+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.stream_progress(+ &ctx.req_id,+ sse_bytes.len() as u64,+ count_sse_events(&sse_bytes),+ None,+ None,+ );+ }let headers = [(http::header::CONTENT_TYPE, "text/event-stream"),@@ -130,7 +142,17 @@ impl Provider for KimiProvider {(headers, sse_bytes).into_response()} else {match accumulate_response(&upstream.body, &message_id, model) {- Ok(json) => (StatusCode::OK, Json(json)).into_response(),+ Ok(json) => {+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.usage_updated(+ &ctx.req_id,+ json.pointer("/usage/input_tokens").and_then(|v| v.as_u64()),+ json.pointer("/usage/output_tokens")+ .and_then(|v| v.as_u64()),+ );+ }+ (StatusCode::OK, Json(json)).into_response()+ }Err(e) => json_error(StatusCode::BAD_GATEWAY,"api_error",@@ -140,8 +162,11 @@ impl Provider for KimiProvider {}}- async fn handle_count_tokens(&self, body: MessagesRequest, _ctx: RequestContext) -> Response {+ async fn handle_count_tokens(&self, body: MessagesRequest, ctx: RequestContext) -> Response {let tokens = count_tokens::count_tokens(&body);+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.usage_updated(&ctx.req_id, Some(tokens), None);+ }(StatusCode::OK,Json(CountTokensResponse {@@ -152,6 +177,10 @@ impl Provider for KimiProvider {}}+fn count_sse_events(bytes: &[u8]) -> u64 {+ String::from_utf8_lossy(bytes).matches("event:").count() as u64+}+fn map_kimi_error_to_response(err: &client::KimiError) -> Response {match err.status {401 | 403 => json_error(diff --git a/src/server.rs b/src/server.rsindex aba25f5..bc29d1a 100644--- a/src/server.rs+++ b/src/server.rs@@ -1,6 +1,7 @@use crate::{anthropic::json_error,logging::{Logger, REDACT_KEYS, create_logger},+ monitor::{EndpointKind, MonitorHandle},provider::RequestContext,registry::{Registry, normalize_incoming_model},session::{self, SessionState},@@ -16,6 +17,7 @@ use axum::{};use serde::de::DeserializeOwned;use serde_json::{Map, Value, json};+use std::future::Future;use std::sync::Arc;use std::time::Instant;use tokio::net::TcpListener;@@ -23,14 +25,38 @@ use uuid::Uuid;pub struct ServerConfig {pub port: u16,+ pub monitor: Option<MonitorHandle>,}pub async fn serve(config: ServerConfig) -> anyhow::Result<()> {+ serve_inner(config, std::future::pending::<()>()).await+}++pub async fn serve_with_shutdown(+ config: ServerConfig,+ shutdown: impl Future<Output = ()> + Send + 'static,+) -> anyhow::Result<()> {+ serve_inner(config, shutdown).await+}++async fn serve_inner(+ config: ServerConfig,+ shutdown: impl Future<Output = ()> + Send + 'static,+) -> anyhow::Result<()> {let listener = TcpListener::bind(("127.0.0.1", config.port)).await?;+ serve_listener(listener, config.monitor, shutdown).await+}++pub async fn serve_listener(+ listener: TcpListener,+ monitor: Option<MonitorHandle>,+ shutdown: impl Future<Output = ()> + Send + 'static,+) -> anyhow::Result<()> {+ let port = listener.local_addr()?.port();create_logger("server").info("server listening",Some(serde_json::Map::from_iter([- ("port".to_string(), json!(config.port)),+ ("port".to_string(), json!(port)),("logDir".to_string(),json!(@@ -41,37 +67,47 @@ pub async fn serve(config: ServerConfig) -> anyhow::Result<()> {),])),);- let app = app(Arc::new(Registry::with_default_alias()));- axum::serve(listener, app).await?;+ let app = app_with_monitor(Arc::new(Registry::with_default_alias()), monitor);+ axum::serve(listener, app)+ .with_graceful_shutdown(shutdown)+ .await?;Ok(())}pub fn app(registry: Arc<Registry>) -> Router {+ app_with_monitor(registry, None)+}++pub fn app_with_monitor(registry: Arc<Registry>, monitor: Option<MonitorHandle>) -> Router {+ let state = Arc::new(AppState { registry, monitor });Router::new().route("/healthz", get(healthz)).route("/v1/messages", post(handler_messages)).route("/v1/messages/count_tokens", post(handler_count_tokens)).fallback(fallback_handler)- .with_state(registry)+ .with_state(state)+}++#[derive(Clone)]+struct AppState {+ registry: Arc<Registry>,+ monitor: Option<MonitorHandle>,}async fn healthz() -> Json<serde_json::Value> {Json(json!({ "ok": true }))}-async fn handler_messages(State(registry): State<Arc<Registry>>, req: Request<Body>) -> Response {- dispatch_request(registry, req, false).await+async fn handler_messages(State(state): State<Arc<AppState>>, req: Request<Body>) -> Response {+ dispatch_request(state, req, false).await}-async fn handler_count_tokens(- State(registry): State<Arc<Registry>>,- req: Request<Body>,-) -> Response {- dispatch_request(registry, req, true).await+async fn handler_count_tokens(State(state): State<Arc<AppState>>, req: Request<Body>) -> Response {+ dispatch_request(state, req, true).await}async fn dispatch_request(- registry: Arc<Registry>,+ state: Arc<AppState>,req: Request<Body>,count_tokens: bool,) -> Response {@@ -83,6 +119,11 @@ async fn dispatch_request(let headers = req.headers().clone();let path = uri.path().to_string();let query = redacted_query(&uri);+ let endpoint = if count_tokens {+ EndpointKind::CountTokens+ } else {+ EndpointKind::Messages+ };log.info("request",Some(serde_json::Map::from_iter([@@ -97,6 +138,9 @@ async fn dispatch_request(.get("x-claude-code-session-id").and_then(|value| value.to_str().ok()).map(std::string::ToString::to_string);+ if let Some(monitor) = state.monitor.as_ref() {+ monitor.request_started(&req_id, session_id.clone(), None, endpoint);+ }let now = current_millis();let body_bytes = match axum::body::to_bytes(req.into_body(), usize::MAX).await {Ok(bytes) => bytes,@@ -117,6 +161,12 @@ async fn dispatch_request(started_at,},);+ monitor_failed(+ state.monitor.as_ref(),+ &req_id,+ Some(response.status()),+ format!("Invalid JSON: {err}"),+ );return response;}};@@ -124,6 +174,7 @@ async fn dispatch_request(let body: crate::anthropic::schema::MessagesRequest = match parse_json_body(&body_bytes) {Ok(body) => body,Err(response) => {+ let status = response.status();log_request_completed(&log,RequestLogContext {@@ -135,6 +186,12 @@ async fn dispatch_request(started_at,},);+ monitor_failed(+ state.monitor.as_ref(),+ &req_id,+ Some(status),+ "Invalid JSON",+ );return *response;}};@@ -147,7 +204,7 @@ async fn dispatch_request("invalid_request_error",format!("Missing \"model\" in request body. {}",- registry.unknown_model_message()+ state.registry.unknown_model_message()),);log_request_completed(@@ -161,6 +218,12 @@ async fn dispatch_request(started_at,},);+ monitor_failed(+ state.monitor.as_ref(),+ &req_id,+ Some(response.status()),+ "Missing model",+ );return response;}};@@ -172,7 +235,7 @@ async fn dispatch_request(None};- let provider = registry.provider_for_model(+ let provider = state.registry.provider_for_model(&normalized_model,session_state.as_ref()@@ -194,7 +257,7 @@ async fn dispatch_request("invalid_request_error",format!("Unknown model \"{normalized_model}\". {}",- registry.unknown_model_message()+ state.registry.unknown_model_message()),);log_request_completed(@@ -208,6 +271,12 @@ async fn dispatch_request(started_at,},);+ monitor_failed(+ state.monitor.as_ref(),+ &req_id,+ Some(response.status()),+ format!("Unknown model \"{normalized_model}\""),+ );return response;}};@@ -219,6 +288,12 @@ async fn dispatch_request(&normalized_model,now,);+ if let Some(monitor) = state.monitor.as_ref() {+ if let Some(current) = current.as_ref() {+ monitor.request_started(&req_id, session_id.clone(), Some(current.seq), endpoint);+ }+ monitor.provider_selected(&req_id, provider.name(), &normalized_model);+ }let traffic = create_traffic_capture(TrafficCaptureOptions {req_id: req_id.clone(),@@ -230,6 +305,9 @@ async fn dispatch_request(.map(Arc::new);if let Some(capture) = traffic.as_ref() {+ if let Some(monitor) = state.monitor.as_ref() {+ monitor.traffic_capture_path(&req_id, capture.root().to_path_buf());+ }capture.write_json("000-metadata",&json!({@@ -257,6 +335,7 @@ async fn dispatch_request(session_seq: current.map(|s| s.seq),provider: provider.name().to_string(),traffic,+ monitor: state.monitor.clone(),};let response = if count_tokens {@@ -275,6 +354,18 @@ async fn dispatch_request(started_at,},);+ if response.status().is_success() {+ if let Some(monitor) = state.monitor.as_ref() {+ monitor.request_completed(&req_id, response.status().as_u16(), None, None);+ }+ } else {+ monitor_failed(+ state.monitor.as_ref(),+ &req_id,+ Some(response.status()),+ format!("HTTP {}", response.status().as_u16()),+ );+ }response}@@ -304,6 +395,17 @@ fn log_request_completed(log: &Logger, ctx: RequestLogContext<'_>) {);}+fn monitor_failed(+ monitor: Option<&MonitorHandle>,+ req_id: &str,+ status: Option<StatusCode>,+ error: impl Into<String>,+) {+ if let Some(monitor) = monitor {+ monitor.request_failed(req_id, status.map(|status| status.as_u16()), error);+ }+}+fn headers_to_record(headers: &http::HeaderMap) -> Value {let mut out = Map::new();for (key, value) in headers {diff --git a/src/traffic.rs b/src/traffic.rsindex 132325b..635ca62 100644--- a/src/traffic.rs+++ b/src/traffic.rs@@ -61,6 +61,10 @@ pub fn create_traffic_capture(opts: TrafficCaptureOptions) -> Option<TrafficCapt}impl TrafficCapture {+ pub fn root(&self) -> &Path {+ &self.root+ }+pub fn write_json(&self, name: &str, value: &Value) {let value = redact_traffic(value);let payload = serde_json::to_string_pretty(&value)diff --git a/src/tui.rs b/src/tui.rsnew file mode 100644index 0000000..3a24f8b--- /dev/null+++ b/src/tui.rs@@ -0,0 +1,382 @@+use std::{+ io::{self, Stdout},+ time::{Duration, SystemTime},+};++use crossterm::{+ event::{self, Event, KeyCode, KeyModifiers},+ execute,+ terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},+};+use ratatui::{+ Terminal,+ backend::CrosstermBackend,+ layout::{Constraint, Direction, Layout, Rect},+ style::{Modifier, Style},+ text::{Line, Span},+ widgets::{Block, Borders, Cell, Paragraph, Row, Table, Wrap},+};+use tokio::sync::oneshot;++use crate::{+ monitor::{ActiveRequest, CompletedRequest, MonitorHandle, MonitorState},+ paths,+ registry::Registry,+};++pub struct MonitorUiConfig<'a> {+ pub port: u16,+ pub registry: &'a Registry,+ pub shutdown: Option<oneshot::Sender<()>>,+}++pub fn run_monitor(+ handle: MonitorHandle,+ config: MonitorUiConfig<'_>,+) -> Result<(), anyhow::Error> {+ let mut terminal = setup_terminal()?;+ let _guard = TerminalGuard;+ let mut app = MonitorApp {+ port: config.port,+ setup_text: setup_text(config.port, config.registry),+ show_setup: true,+ show_help: false,+ detail: false,+ selected: 0,+ shutdown: config.shutdown,+ };++ loop {+ let state = handle.snapshot();+ terminal.draw(|frame| render(frame, &mut app, &state))?;+ if event::poll(Duration::from_millis(250))? {+ match event::read()? {+ Event::Key(key) => match key.code {+ KeyCode::Char('q') | KeyCode::Char('c')+ if key.modifiers.contains(KeyModifiers::CONTROL) =>+ {+ if let Some(shutdown) = app.shutdown.take() {+ let _ = shutdown.send(());+ }+ break;+ }+ KeyCode::Char('?') => app.show_help = !app.show_help,+ KeyCode::Char('b') => app.show_setup = !app.show_setup,+ KeyCode::Down | KeyCode::Char('j') => {+ app.selected = app.selected.saturating_add(1)+ }+ KeyCode::Up | KeyCode::Char('k') => {+ app.selected = app.selected.saturating_sub(1)+ }+ KeyCode::Enter => app.detail = true,+ KeyCode::Esc => app.detail = false,+ _ => {}+ },+ Event::Resize(_, _) => {}+ _ => {}+ }+ }+ }+ terminal.show_cursor()?;+ Ok(())+}++struct MonitorApp {+ port: u16,+ setup_text: String,+ show_setup: bool,+ show_help: bool,+ detail: bool,+ selected: usize,+ shutdown: Option<oneshot::Sender<()>>,+}++impl Drop for MonitorApp {+ fn drop(&mut self) {+ if let Some(shutdown) = self.shutdown.take() {+ let _ = shutdown.send(());+ }+ }+}++struct TerminalGuard;++impl Drop for TerminalGuard {+ fn drop(&mut self) {+ let _ = disable_raw_mode();+ let _ = execute!(io::stdout(), LeaveAlternateScreen);+ }+}++fn setup_terminal() -> Result<Terminal<CrosstermBackend<Stdout>>, anyhow::Error> {+ enable_raw_mode()?;+ execute!(io::stdout(), EnterAlternateScreen)?;+ let backend = CrosstermBackend::new(io::stdout());+ let mut terminal = Terminal::new(backend)?;+ terminal.clear()?;+ Ok(terminal)+}++fn render(frame: &mut ratatui::Frame<'_>, app: &mut MonitorApp, state: &MonitorState) {+ let root = Layout::default()+ .direction(Direction::Vertical)+ .constraints([+ Constraint::Length(3),+ if app.show_setup {+ Constraint::Length(9)+ } else {+ Constraint::Length(0)+ },+ Constraint::Percentage(38),+ Constraint::Percentage(38),+ Constraint::Length(if app.show_help { 5 } else { 3 }),+ ])+ .split(frame.area());++ render_header(frame, root[0], app, state);+ if app.show_setup {+ frame.render_widget(+ Paragraph::new(app.setup_text.as_str())+ .block(Block::default().title("Setup").borders(Borders::ALL))+ .wrap(Wrap { trim: false }),+ root[1],+ );+ }+ if app.detail {+ render_detail(frame, root[2], state, app.selected);+ } else {+ render_active(frame, root[2], &state.active);+ }+ render_recent(frame, root[3], &state.recent);+ render_footer(frame, root[4], app);+}++fn render_header(+ frame: &mut ratatui::Frame<'_>,+ area: Rect,+ app: &MonitorApp,+ state: &MonitorState,+) {+ let uptime = state+ .started_at+ .elapsed()+ .unwrap_or_else(|_| Duration::from_secs(0));+ let text = Line::from(vec![+ Span::styled(+ "claude-code-proxy",+ Style::default().add_modifier(Modifier::BOLD),+ ),+ Span::raw(format!(+ " http://127.0.0.1:{} uptime {} active {}",+ app.port,+ format_duration(uptime),+ state.active.len()+ )),+ ]);+ frame.render_widget(+ Paragraph::new(text).block(Block::default().borders(Borders::ALL)),+ area,+ );+}++fn render_active(frame: &mut ratatui::Frame<'_>, area: Rect, active: &[ActiveRequest]) {+ let rows = active.iter().map(|request| {+ Row::new(vec![+ Cell::from(format_system_time(request.started_at)),+ Cell::from(request.provider.as_deref().unwrap_or("-")),+ Cell::from(request.model.as_deref().unwrap_or("-")),+ Cell::from(request.endpoint.label()),+ Cell::from(request.status.label()),+ Cell::from(request.rate().label()),+ Cell::from(format_duration(request.elapsed())),+ ])+ });+ let table = Table::new(+ rows,+ [+ Constraint::Length(8),+ Constraint::Length(10),+ Constraint::Percentage(24),+ Constraint::Length(12),+ Constraint::Length(10),+ Constraint::Length(12),+ Constraint::Length(9),+ ],+ )+ .header(Row::new([+ "started", "provider", "model", "endpoint", "status", "rate", "elapsed",+ ]))+ .block(+ Block::default()+ .title("Active requests")+ .borders(Borders::ALL),+ );+ frame.render_widget(table, area);+}++fn render_recent(frame: &mut ratatui::Frame<'_>, area: Rect, recent: &[CompletedRequest]) {+ let rows = recent.iter().map(|request| {+ let tokens = match (request.input_tokens, request.output_tokens) {+ (Some(input), Some(output)) => format!("{input}/{output}"),+ (Some(input), None) => input.to_string(),+ (None, Some(output)) => output.to_string(),+ (None, None) => "-".to_string(),+ };+ Row::new(vec![+ Cell::from(format_system_time(request.finished_at)),+ Cell::from(+ request+ .http_status+ .map(|status| status.to_string())+ .unwrap_or_else(|| "-".to_string()),+ ),+ Cell::from(request.provider.as_deref().unwrap_or("-")),+ Cell::from(request.model.as_deref().unwrap_or("-")),+ Cell::from(format_duration(request.latency)),+ Cell::from(tokens),+ Cell::from(request.error.as_deref().unwrap_or("")),+ ])+ });+ let table = Table::new(+ rows,+ [+ Constraint::Length(8),+ Constraint::Length(6),+ Constraint::Length(10),+ Constraint::Percentage(24),+ Constraint::Length(9),+ Constraint::Length(11),+ Constraint::Percentage(30),+ ],+ )+ .header(Row::new([+ "finished", "status", "provider", "model", "latency", "tokens", "error",+ ]))+ .block(+ Block::default()+ .title("Recent requests")+ .borders(Borders::ALL),+ );+ frame.render_widget(table, area);+}++fn render_detail(+ frame: &mut ratatui::Frame<'_>,+ area: Rect,+ state: &MonitorState,+ selected: usize,+) {+ let lines = if let Some(request) = state.active.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!(+ "provider: {}",+ request.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())+ )),+ Line::from(format!(+ "error: {}",+ request.error.as_deref().unwrap_or("-")+ )),+ ]+ } else {+ vec![Line::from("No active request selected")]+ };+ frame.render_widget(+ Paragraph::new(lines).block(+ Block::default()+ .title("Request detail")+ .borders(Borders::ALL),+ ),+ area,+ );+}++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"+ } else {+ "q quit ? help b setup Enter detail"+ };+ frame.render_widget(+ Paragraph::new(hints).block(Block::default().borders(Borders::ALL)),+ area,+ );+}++pub fn setup_text(port: u16, registry: &Registry) -> String {+ let mut lines = vec![+ format!("Logs: {}", paths::log_file().display()),+ format!("Config: {}", paths::config_dir().display()),+ ];+ for provider in ["codex", "kimi", "cursor"] {+ if let Some(models) = registry.grouped_models().get(provider) {+ lines.push(format!("{provider}: {}", models.join(", ")));+ }+ }+ lines.push(format!(+ "export ANTHROPIC_BASE_URL=\"http://localhost:{port}\""+ ));+ lines.push("export ANTHROPIC_AUTH_TOKEN=\"anything\"".to_string());+ lines.push("export ANTHROPIC_MODEL=\"gpt-5.5\"".to_string());+ lines.push("export ANTHROPIC_SMALL_FAST_MODEL=\"gpt-5.4-mini\"".to_string());+ lines.push("export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1".to_string());+ lines.join("\n")+}++fn format_duration(duration: Duration) -> String {+ let total = duration.as_secs();+ let hours = total / 3600;+ let minutes = (total % 3600) / 60;+ let seconds = total % 60;+ if hours > 0 {+ format!("{hours}h{minutes:02}m")+ } else if minutes > 0 {+ format!("{minutes}m{seconds:02}s")+ } else {+ format!("{seconds}s")+ }+}++fn format_system_time(time: SystemTime) -> String {+ let Ok(duration) = time.duration_since(SystemTime::UNIX_EPOCH) else {+ return "-".to_string();+ };+ let seconds = duration.as_secs() % 86_400;+ format!(+ "{:02}:{:02}:{:02}",+ seconds / 3600,+ (seconds % 3600) / 60,+ seconds % 60+ )+}++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(),+ }+}diff --git a/tests/cursor_native.rs b/tests/cursor_native.rsindex 9c79385..fb38171 100644--- a/tests/cursor_native.rs+++ b/tests/cursor_native.rs@@ -683,6 +683,7 @@ async fn cursor_provider_handle_messages_returns_anthropic_json() {session_seq: None,provider: "cursor".into(),traffic: None,+ monitor: None,};let response = provider.handle_messages(body, ctx).await;diff --git a/tests/server.rs b/tests/server.rsindex f8281dc..ebfe761 100644--- a/tests/server.rs+++ b/tests/server.rs@@ -1,6 +1,10 @@use axum::body::Body;use axum::http::{Method, Request, StatusCode};-use claude_code_proxy::{registry::Registry, server::app};+use claude_code_proxy::{+ monitor::{MonitorHandle, RequestStatus},+ registry::Registry,+ server::{app, app_with_monitor},+};use serde_json::{Value, json};use std::sync::Arc;use tower::util::ServiceExt;@@ -198,3 +202,93 @@ async fn unknown_routes_use_anthropic_not_found_error() {.unwrap();assert_eq!(body["type"].as_str().unwrap_or(""), "error");}++#[tokio::test]+async fn monitor_records_successful_request_events() {+ let monitor = MonitorHandle::new(10);+ let app = app_with_monitor(+ Arc::new(Registry::with_default_alias()),+ Some(monitor.clone()),+ );+ let response = app+ .oneshot(+ Request::builder()+ .method(Method::POST)+ .uri("/v1/messages/count_tokens")+ .header("content-type", "application/json")+ .body(body_string(+ r#"{"model":"gpt-5.4","messages":[{"role":"user","content":"hello"}]}"#,+ ))+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::OK);+ let state = monitor.snapshot();+ assert!(state.active.is_empty());+ assert_eq!(state.recent.len(), 1);+ assert_eq!(state.recent[0].status, RequestStatus::Completed);+ assert_eq!(state.recent[0].http_status, Some(200));+ assert_eq!(state.recent[0].provider.as_deref(), Some("codex"));+ assert_eq!(state.recent[0].model.as_deref(), Some("gpt-5.4"));+ assert!(state.recent[0].input_tokens.is_some());+}++#[tokio::test]+async fn monitor_records_invalid_json_failure() {+ let monitor = MonitorHandle::new(10);+ let app = app_with_monitor(+ Arc::new(Registry::with_default_alias()),+ Some(monitor.clone()),+ );+ let response = app+ .oneshot(+ Request::builder()+ .method(Method::POST)+ .uri("/v1/messages")+ .body(body_string("{"))+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::BAD_REQUEST);+ let state = monitor.snapshot();+ assert!(state.active.is_empty());+ assert_eq!(state.recent[0].status, RequestStatus::Failed);+ assert_eq!(state.recent[0].http_status, Some(400));+ assert_eq!(state.recent[0].error.as_deref(), Some("Invalid JSON"));+}++#[tokio::test]+async fn monitor_records_unknown_model_failure() {+ let monitor = MonitorHandle::new(10);+ let app = app_with_monitor(+ Arc::new(Registry::with_default_alias()),+ Some(monitor.clone()),+ );+ let response = app+ .oneshot(+ Request::builder()+ .method(Method::POST)+ .uri("/v1/messages")+ .header("content-type", "application/json")+ .body(body_string(+ r#"{"messages":[{"role":"user","content":"hello"}],"model":"not-a-model"}"#,+ ))+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::BAD_REQUEST);+ let state = monitor.snapshot();+ assert!(state.active.is_empty());+ assert_eq!(state.recent[0].status, RequestStatus::Failed);+ assert_eq!(state.recent[0].http_status, Some(400));+ assert_eq!(+ state.recent[0].error.as_deref(),+ Some("Unknown model \"not-a-model\"")+ );+}