Skip to content

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.lock
index 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.toml
index 11b994d..d7751c6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,6 +36,8 @@ tokio-tungstenite = { version = "0.24", default-features = false, features = ["c
url = "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.rs
index 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.rs
index 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, &registry);
- 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, &registry);
+ 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: &registry,
+ 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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 continuation
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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\"")
+ );
+}