Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
add rich Grok traffic capture
Raine Virtabef203f3b35e
diff --git a/src/providers/grok/client.rs b/src/providers/grok/client.rsindex e0d17f0..6d9a6f0 100644--- a/src/providers/grok/client.rs+++ b/src/providers/grok/client.rs@@ -1,5 +1,5 @@use std::sync::Arc;-use std::time::Duration;+use std::time::{Duration, Instant};use futures_util::StreamExt;use http::StatusCode;@@ -7,6 +7,7 @@ use http::StatusCode;use super::auth::manager::GrokAuthManager;use super::auth::token_store::{StoredAuth, file_store};use super::translate::request::GrokResponsesRequest;+use crate::traffic::TrafficCapture;const DEFAULT_BASE_URL: &str = "https://cli-chat-proxy.grok.com/v1";const MAX_BUFFERED_RESPONSE_BYTES: usize = 8 * 1024 * 1024;@@ -94,29 +95,72 @@ impl GrokClient {}}- pub async fn post(&self, body: &GrokResponsesRequest) -> Result<GrokResponse, GrokError> {- let auth = self.auth.get_auth().await.map_err(auth_error)?;- let response = self.attempt(&auth.access, body).await?;+ pub async fn post(+ &self,+ body: &GrokResponsesRequest,+ traffic: Option<Arc<TrafficCapture>>,+ ) -> Result<GrokResponse, GrokError> {+ if let Some(capture) = traffic.as_ref() {+ let body_value = serde_json::to_value(body).unwrap_or(serde_json::Value::Null);+ capture.write_json("020-upstream-request", &body_value);+ capture.write_json("021-upstream-request-metadata", &serde_json::json!({+ "method": "POST", "url": safe_url(&self.url), "provider": "grok", "transport": "http",+ "headers": {"accept":"text/event-stream", "content-type":"application/json", "authorization":"[redacted]", "x-xai-token-auth":"[redacted]"},+ "body_bytes": serde_json::to_vec(body).map(|v| v.len()).unwrap_or(0),+ }));+ }+ let auth = match self.auth.get_auth().await {+ Ok(auth) => auth,+ Err(error) => {+ capture_failure(traffic.as_deref(), "auth", "authentication", 0);+ return Err(auth_error(error));+ }+ };+ let response = self+ .attempt(&auth.access, body, 1, traffic.as_deref())+ .await?;if response.status() == StatusCode::UNAUTHORIZED {let refreshed = self.auth.force_refresh(&auth.access).await- .map_err(auth_error)?;- let replay = self.attempt(&refreshed.access, body).await?;+ .map_err(|error| {+ capture_failure(traffic.as_deref(), "auth", "refresh", 1);+ auth_error(error)+ })?;+ let replay = self+ .attempt(&refreshed.access, body, 2, traffic.as_deref())+ .await?;if replay.status() == StatusCode::UNAUTHORIZED {+ capture_failure(traffic.as_deref(), "auth", "unauthorized", 2);return Err(auth_error(anyhow::anyhow!("unauthorized")));}- return Ok(GrokResponse { response: replay });+ return Ok(self.captured_response(replay, traffic.as_deref()));}- Ok(GrokResponse { response })+ Ok(self.captured_response(response, traffic.as_deref()))+ }++ fn captured_response(+ &self,+ response: reqwest::Response,+ traffic: Option<&TrafficCapture>,+ ) -> GrokResponse {+ if let Some(capture) = traffic.as_ref() {+ capture.write_json("030-upstream-response-headers", &serde_json::json!({+ "status": response.status().as_u16(), "headers": safe_headers(response.headers()),+ }));+ }+ GrokResponse { response }}async fn attempt(&self,access: &str,body: &GrokResponsesRequest,+ attempt: u8,+ traffic: Option<&TrafficCapture>,) -> Result<reqwest::Response, GrokError> {+ let started = Instant::now();let response = self.client.post(&self.url)@@ -129,20 +173,36 @@ impl GrokClient {.json(body).send().await- .map_err(|_| GrokError {- status: StatusCode::BAD_GATEWAY,- retry_after: None,- message: "Grok upstream request failed".into(),+ .map_err(|_| {+ capture_failure(traffic, "transport", "transport", attempt);+ GrokError {+ status: StatusCode::BAD_GATEWAY,+ retry_after: None,+ message: "Grok upstream request failed".into(),+ }})?;let status = response.status();+ if let Some(capture) = traffic {+ capture.write_json("022-upstream-attempt", &serde_json::json!({"attempt":attempt,"status":status.as_u16(),"elapsed_ms":started.elapsed().as_millis(),"headers":safe_headers(response.headers())}));+ }if !status.is_success() && status != StatusCode::UNAUTHORIZED {+ let retry_after = response+ .headers()+ .get("retry-after")+ .and_then(|v| v.to_str().ok())+ .map(str::to_string);+ if let Some(capture) = traffic {+ let (body, truncated) = read_rejected_body(response, 64 * 1024).await;+ let detail = serde_json::from_slice::<serde_json::Value>(&body)+ .unwrap_or_else(|_| serde_json::json!({"body_bytes": body.len()}));+ capture.write_json(+ "031-upstream-error-body",+ &serde_json::json!({"attempt":attempt,"status":status.as_u16(),"truncated":truncated,"body":detail}),+ );+ }return Err(GrokError {status,- retry_after: response- .headers()- .get("retry-after")- .and_then(|v| v.to_str().ok())- .map(str::to_string),+ retry_after,message: "Grok upstream rejected the request".into(),});}@@ -150,6 +210,63 @@ impl GrokClient {}}+async fn read_rejected_body(response: reqwest::Response, limit: usize) -> (Vec<u8>, bool) {+ let mut body = Vec::new();+ let mut stream = response.bytes_stream();+ while let Some(chunk) = stream.next().await {+ let Ok(chunk) = chunk else { break };+ let remaining = limit.saturating_sub(body.len());+ if chunk.len() > remaining {+ body.extend_from_slice(&chunk[..remaining]);+ return (body, true);+ }+ body.extend_from_slice(&chunk);+ }+ (body, false)+}++pub(super) fn capture_failure(+ traffic: Option<&TrafficCapture>,+ stage: &str,+ kind: &str,+ attempt: u8,+) {+ if let Some(capture) = traffic {+ capture.write_json(+ "060-grok-stream-error",+ &serde_json::json!({"stage":stage,"kind":kind,"attempt":attempt}),+ );+ }+}++fn safe_headers(headers: &reqwest::header::HeaderMap) -> serde_json::Value {+ let mut result = serde_json::Map::new();+ for name in [+ "content-type",+ "content-length",+ "retry-after",+ "x-request-id",+ ] {+ if let Some(value) = headers.get(name).and_then(|value| value.to_str().ok()) {+ result.insert(+ name.to_string(),+ serde_json::Value::String(value.to_string()),+ );+ }+ }+ serde_json::Value::Object(result)+}++fn safe_url(raw: &str) -> String {+ let Ok(mut url) = reqwest::Url::parse(raw) else {+ return "[invalid-url]".into();+ };+ let _ = url.set_username("");+ let _ = url.set_password(None);+ url.set_query(None);+ url.to_string()+}+fn url_for(base_url: String) -> anyhow::Result<String> {responses_url(&base_url)}diff --git a/src/providers/grok/mod.rs b/src/providers/grok/mod.rsindex 38da460..1dc2a8b 100644--- a/src/providers/grok/mod.rs+++ b/src/providers/grok/mod.rs@@ -23,11 +23,11 @@ use crate::anthropic::{};use crate::monitor::MonitorHandle;use crate::provider::{CliHandlers, Provider, RequestContext};-use crate::registry::GROK_MODELS;+use crate::{registry::GROK_MODELS, traffic::StreamTrafficCapture};use self::auth::token_store::file_store;use self::translate::{- accumulate::accumulate_response,+ accumulate::accumulate_response_with_traffic,model_allowlist::{assert_allowed_model, resolve_model},request::translate_request,stream::{SseDecoder, StreamTranslator, stream_error},@@ -99,7 +99,7 @@ impl Provider for GrokProvider {monitor.model_resolved(&ctx.req_id, &resolved);monitor.upstream_started(&ctx.req_id);}- let upstream = match self.client.post(&translated).await {+ let upstream = match self.client.post(&translated, ctx.traffic.clone()).await {Ok(response) => response,Err(error) => return map_error(error),};@@ -110,18 +110,26 @@ impl Provider for GrokProvider {requested,ctx.monitor.clone(),ctx.req_id.clone(),+ ctx.traffic.clone(),)} else {let upstream_bytes = match upstream.into_bytes().await {Ok(bytes) => bytes,- Err(error) => return map_error(error),+ Err(error) => {+ write_error(ctx.traffic.as_deref(), "body_read", "transport");+ return map_error(error);+ }};- match accumulate_response(+ match accumulate_response_with_traffic(&upstream_bytes,&format!("msg_{}", uuid::Uuid::new_v4().simple()),&requested,+ ctx.traffic.as_deref(),) {Ok(value) => {+ if let Some(traffic) = ctx.traffic.as_ref() {+ traffic.write_json("051-downstream-response", &value);+ }if let Some(monitor) = ctx.monitor.as_ref() {monitor.usage_updated(&ctx.req_id,@@ -135,11 +143,14 @@ impl Provider for GrokProvider {}(StatusCode::OK, Json(value)).into_response()}- Err(_) => json_error(- StatusCode::BAD_GATEWAY,- "api_error",- "Grok response is invalid",- ),+ Err(_) => {+ write_error(ctx.traffic.as_deref(), "accumulate", "invalid_response");+ json_error(+ StatusCode::BAD_GATEWAY,+ "api_error",+ "Grok response is invalid",+ )+ }}}}@@ -183,8 +194,16 @@ fn stream_response(model: String,monitor: Option<MonitorHandle>,req_id: String,+ traffic: Option<Arc<crate::traffic::TrafficCapture>>,) -> Response {- stream_body(response.into_stream(), message_id, model, monitor, req_id)+ stream_body(+ response.into_stream(),+ message_id,+ model,+ monitor,+ req_id,+ traffic,+ )}fn stream_body<S>(@@ -193,6 +212,7 @@ fn stream_body<S>(model: String,monitor: Option<MonitorHandle>,req_id: String,+ traffic: Option<Arc<crate::traffic::TrafficCapture>>,) -> ResponsewhereS: Stream<Item = Result<Bytes, client::GrokError>> + Unpin + Send + 'static,@@ -208,6 +228,8 @@ wherereq_id,bytes: 0,chunks: 0,+ stream_capture: traffic.as_ref().map(|traffic| traffic.stream_capture()),+ traffic,};let stream = futures_util::stream::unfold(state, |mut state| async move {state@@ -236,6 +258,8 @@ struct GrokStreamState<S> {req_id: String,bytes: u64,chunks: u64,+ stream_capture: Option<StreamTrafficCapture>,+ traffic: Option<Arc<crate::traffic::TrafficCapture>>,}impl<S> GrokStreamState<S>@@ -253,12 +277,13 @@ whereloop {let chunk = match self.upstream.next().await {Some(Ok(chunk)) => chunk,- Some(Err(_)) => return Some(self.fail()),+ Some(Err(_)) => return Some(self.fail_at("transport", "upstream_stream")),None => {if self.decoder.finish().is_err() || !self.reducer.finished() {- return Some(self.fail());+ return Some(self.fail_at("decoder", "incomplete_stream"));}self.terminal = true;+ self.finish_capture(true);return None;}};@@ -269,17 +294,25 @@ where}let events = match self.decoder.push(&chunk) {Ok(events) => events,- Err(_) => return Some(self.fail()),+ Err(_) => return Some(self.fail_at("decoder", "malformed_sse")),};let mut out = Vec::new();for event in events {let value: serde_json::Value = match serde_json::from_str(&event.data) {Ok(value) => value,- Err(_) => return Some(self.fail()),+ Err(_) => {+ if let Some(capture) = self.stream_capture.as_mut() {+ capture.malformed("json", "malformed_event");+ }+ return Some(self.fail_at("json", "malformed_event"));+ }};+ if let Some(capture) = self.stream_capture.as_mut() {+ capture.upstream_event(event.event.as_deref(), &value);+ }let reduced = match self.reducer.push(value) {Ok(events) => events,- Err(_) => return Some(self.fail()),+ Err(_) => return Some(self.fail_at("reducer", "invalid_event")),};let usage = reduced.iter().find_map(|event| match event {translate::reducer::ReducerEvent::Finish {@@ -291,7 +324,7 @@ where});match self.translator.render(reduced) {Ok(bytes) => out.extend(bytes),- Err(_) => return Some(self.fail()),+ Err(_) => return Some(self.fail_at("render", "invalid_event")),}if let Some((input_tokens, output_tokens)) = usage&& let Some(monitor) = self.monitor.as_ref()@@ -300,19 +333,99 @@ where}if self.reducer.finished() {self.terminal = true;+ self.capture_downstream(&out);+ self.finish_capture(true);return if out.is_empty() { None } else { Some(out) };}}if !out.is_empty() {+ self.capture_downstream(&out);return Some(out);}}}- fn fail(&mut self) -> Vec<u8> {+ fn fail_at(&mut self, stage: &str, kind: &str) -> Vec<u8> {self.error_sent = true;+ if let Some(capture) = self.stream_capture.as_mut() {+ capture.malformed(stage, kind);+ capture.downstream_event("error", serde_json::json!({"type":"error","error":{"type":"api_error","message":"Grok stream is invalid"}}));+ }+ if let Some(traffic) = self.traffic.as_ref() {+ traffic.write_json("060-grok-stream-error", &serde_json::json!({"stage":stage,"kind":kind,"bytes":self.bytes,"chunks":self.chunks}));+ }+ self.finish_capture(false);stream_error()}++ fn capture_downstream(&mut self, bytes: &[u8]) {+ let Some(capture) = self.stream_capture.as_mut() else {+ return;+ };+ let mut decoder = SseDecoder::default();+ if let Ok(events) = decoder.push(bytes) {+ for event in events {+ if let Ok(data) = serde_json::from_str(&event.data) {+ capture.downstream_event(event.event.as_deref().unwrap_or("message"), data);+ }+ }+ }+ }++ fn finish_capture(&mut self, completed: bool) {+ if let (Some(capture), Some(traffic)) = (self.stream_capture.take(), self.traffic.as_ref())+ {+ capture.finish(+ traffic,+ serde_json::json!({+ "kind": if completed { "stream_completion" } else { "stream_error" },+ "bytes": self.bytes,+ "chunks": self.chunks,+ }),+ );+ }+ }+}++impl<S> Drop for GrokStreamState<S> {+ fn drop(&mut self) {+ if self.terminal || self.stream_capture.is_none() {+ return;+ }+ if let Some(traffic) = self.traffic.as_ref() {+ traffic.write_json(+ "060-grok-stream-abandoned",+ &serde_json::json!({+ "stage": "downstream",+ "kind": "client_disconnect",+ "reason": "downstream_body_dropped",+ "bytes": self.bytes,+ "chunks": self.chunks,+ }),+ );+ }+ if let (Some(capture), Some(traffic)) = (self.stream_capture.take(), self.traffic.as_ref())+ {+ capture.finish(+ traffic,+ serde_json::json!({+ "kind": "stream_abandoned",+ "reason": "downstream_body_dropped",+ "bytes": self.bytes,+ "chunks": self.chunks,+ }),+ );+ }+ }+}++fn write_error(traffic: Option<&crate::traffic::TrafficCapture>, stage: &str, kind: &str) {+ if let Some(traffic) = traffic {+ traffic.write_json(+ "060-grok-stream-error",+ &serde_json::json!({"stage":stage,"kind":kind}),+ );+ }}fn map_error(error: client::GrokError) -> Response {@@ -389,7 +502,9 @@ mod tests {use std::time::Duration;use crate::monitor::{EndpointKind, MonitorHandle};+ use crate::traffic::test_capture;use http_body_util::BodyExt;+ use tempfile::TempDir;use tokio::sync::mpsc;use super::*;@@ -425,6 +540,7 @@ mod tests {"grok-4.5".into(),Some(monitor.clone()),"req_1".into(),+ None,);let _ = response.into_body().collect().await.unwrap();@@ -456,6 +572,7 @@ mod tests {"grok-4.5".into(),None,"req_1".into(),+ None,);let mut body = response.into_body();@@ -500,4 +617,209 @@ mod tests {.is_none());}++ #[tokio::test]+ async fn dropped_downstream_body_finalizes_partial_capture() {+ let temp = TempDir::new().unwrap();+ let traffic = Arc::new(test_capture(temp.path().join("traffic")));+ let (tx, rx) = mpsc::channel(2);+ let response = stream_body(+ ChannelStream(rx),+ "msg_1".into(),+ "grok-4.5".into(),+ None,+ "req_1".into(),+ Some(traffic),+ );+ let mut body = response.into_body();++ tx.send(Ok(Bytes::from_static(+ b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"partial\"}\n\n",+ )))+ .await+ .unwrap();+ let _ = body.frame().await.unwrap().unwrap();+ drop(body);++ let entries: Vec<_> = std::fs::read_dir(temp.path().join("traffic"))+ .unwrap()+ .map(|entry| entry.unwrap().path())+ .collect();+ let abandoned = entries+ .iter()+ .find(|path| path.to_string_lossy().contains("060-grok-stream-abandoned"))+ .unwrap();+ let summary = entries+ .iter()+ .find(|path| path.to_string_lossy().contains("061-grok-stream-summary"))+ .unwrap();+ let abandoned: serde_json::Value =+ serde_json::from_slice(&std::fs::read(abandoned).unwrap()).unwrap();+ let summary: serde_json::Value =+ serde_json::from_slice(&std::fs::read(summary).unwrap()).unwrap();+ assert_eq!(abandoned["kind"], "client_disconnect");+ assert_eq!(summary["completion"]["kind"], "stream_abandoned");+ assert_eq!(summary["completion"]["reason"], "downstream_body_dropped");+ assert_eq!(summary["completion"]["chunks"], 1);+ assert!(summary["upstream_events"]["captured"].as_u64().unwrap() > 0);+ assert!(summary["downstream_events"]["captured"].as_u64().unwrap() > 0);+ }++ #[tokio::test]+ async fn streaming_capture_writes_redacted_complete_artifacts() {+ let temp = TempDir::new().unwrap();+ let traffic = Arc::new(test_capture(temp.path().join("traffic")));+ let upstream = futures_util::stream::iter(vec![Ok(Bytes::from_static(+ b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"first\"}\n\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"type\":\"function_call\",\"call_id\":\"call_1\",\"name\":\"lookup\"}}\n\ndata: {\"type\":\"response.function_call_arguments.delta\",\"call_id\":\"call_1\",\"delta\":\"{}\"}\n\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"function_call\",\"call_id\":\"call_1\"}}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"usage\":{}}}\n\n",+ ))]);+ let response = stream_body(+ upstream,+ "msg_1".into(),+ "grok-4.5".into(),+ None,+ "req_1".into(),+ Some(traffic),+ );+ let body = response.into_body().collect().await.unwrap().to_bytes();+ assert!(String::from_utf8_lossy(&body).contains("tool_use"));+ let names: Vec<_> = std::fs::read_dir(temp.path().join("traffic"))+ .unwrap()+ .map(|entry| entry.unwrap().file_name().to_string_lossy().into_owned())+ .collect();+ assert!(+ names+ .iter()+ .any(|name| name.contains("032-upstream-response-body.sse"))+ );+ assert!(+ names+ .iter()+ .any(|name| name.contains("061-grok-stream-summary"))+ );+ }++ #[tokio::test]+ async fn streaming_capture_records_fragmented_search_and_tool_events() {+ let temp = TempDir::new().unwrap();+ let traffic = Arc::new(test_capture(temp.path().join("traffic")));+ let upstream = futures_util::stream::iter(vec![+ Ok(Bytes::from_static(+ b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"fir",+ )),+ Ok(Bytes::from_static(+ b"st\"}\n\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"type\":\"custom_tool_call\",\"name\":\"x_search\",\"id\":\"search_1\"}}\n\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"custom_tool_call\",\"name\":\"x_search\",\"id\":\"search_1\"}}\n\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"type\":\"function_call\",\"call_id\":\"call_1\",\"name\":\"lookup\"}}\n\ndata: {\"type\":\"response.function_call_arguments.delta\",\"call_id\":\"call_1\",\"delta\":\"{}\"}\n\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"function_call\",\"call_id\":\"call_1\"}}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"usage\":{}}}\n\n",+ )),+ ]);+ let response = stream_body(+ upstream,+ "msg_1".into(),+ "grok-4.5".into(),+ None,+ "req_1".into(),+ Some(traffic),+ );+ let body = response.into_body().collect().await.unwrap().to_bytes();+ assert!(String::from_utf8_lossy(&body).contains("tool_use"));+ let captured = capture_contents(temp.path().join("traffic"));+ assert!(captured.contains("x_search"));+ assert!(captured.contains("function_call"));+ assert!(captured.contains("stream_completion"));+ }++ #[tokio::test]+ async fn streaming_capture_records_malformed_and_failed_streams() {+ for (payload, stage) in [+ (b"data: {bad json}\n\n".as_slice(), "json"),+ (+ b"data: {\"type\":\"response.failed\",\"response\":{}}\n\n".as_slice(),+ "reducer",+ ),+ ] {+ let temp = TempDir::new().unwrap();+ let traffic = Arc::new(test_capture(temp.path().join("traffic")));+ let response = stream_body(+ futures_util::stream::iter(vec![Ok(Bytes::copy_from_slice(payload))]),+ "msg_1".into(),+ "grok-4.5".into(),+ None,+ "req_1".into(),+ Some(traffic),+ );+ let body = response.into_body().collect().await.unwrap().to_bytes();+ assert!(String::from_utf8_lossy(&body).contains("event: error"));+ let captured = capture_contents(temp.path().join("traffic"));+ assert!(captured.contains(&format!("\"stage\": \"{stage}\"")));+ assert!(captured.contains("stream_error"));+ }+ }++ #[test]+ fn non_streaming_malformed_capture_keeps_diagnostics() {+ let temp = TempDir::new().unwrap();+ let traffic = test_capture(temp.path().join("traffic"));+ assert!(+ accumulate_response_with_traffic(+ b"data: {bad json}\n\n",+ "msg_1",+ "grok-4.5",+ Some(&traffic),+ )+ .is_err()+ );+ let captured = capture_contents(temp.path().join("traffic"));+ assert!(captured.contains("malformed_event"));+ assert!(captured.contains("\"outcome\": \"error\""));+ }++ #[test]+ fn transport_failure_capture_contains_no_credentials() {+ let temp = TempDir::new().unwrap();+ let traffic = test_capture(temp.path().join("traffic"));+ client::capture_failure(Some(&traffic), "transport", "transport", 1);+ let captured = capture_contents(temp.path().join("traffic"));+ assert!(captured.contains("transport"));+ for secret in [+ "Bearer token",+ "refresh-secret",+ "oauth-code",+ "[email protected]",+ ] {+ assert!(!captured.contains(secret));+ }+ }++ fn capture_contents(root: std::path::PathBuf) -> String {+ let mut captured = String::new();+ let mut pending = vec![root];+ while let Some(path) = pending.pop() {+ for entry in std::fs::read_dir(path).unwrap() {+ let path = entry.unwrap().path();+ if path.is_dir() {+ pending.push(path);+ } else {+ captured.push_str(&std::fs::read_to_string(path).unwrap());+ }+ }+ }+ captured+ }++ #[test]+ fn non_streaming_capture_writes_response_and_redacts_secrets() {+ let temp = TempDir::new().unwrap();+ let traffic = test_capture(temp.path().join("traffic"));+ let upstream = b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"ok\",\"access_token\":\"secret\"}\n\ndata: {\"type\":\"response.completed\",\"response\":{}}\n\n";+ let value = accumulate_response_with_traffic(upstream, "msg_1", "grok-4.5", Some(&traffic))+ .unwrap();+ traffic.write_json("051-downstream-response", &value);+ let mut captured = String::new();+ for entry in std::fs::read_dir(temp.path().join("traffic")).unwrap() {+ let path = entry.unwrap().path();+ if path.is_file() {+ captured.push_str(&std::fs::read_to_string(path).unwrap());+ }+ }+ assert!(captured.contains("[redacted len=6]"));+ assert!(!captured.contains("secret"));+ }}diff --git a/src/providers/grok/translate/accumulate.rs b/src/providers/grok/translate/accumulate.rsindex bb448a1..cef3621 100644--- a/src/providers/grok/translate/accumulate.rs+++ b/src/providers/grok/translate/accumulate.rs@@ -1,6 +1,7 @@use std::collections::HashMap;use super::reducer::{ReducerEvent, reduce_upstream_bytes};+use crate::traffic::TrafficCapture;use serde_json::Value;pub fn accumulate_response(@@ -8,12 +9,58 @@ pub fn accumulate_response(message_id: &str,model: &str,) -> anyhow::Result<Value> {+ accumulate_response_with_traffic(upstream, message_id, model, None)+}++pub fn accumulate_response_with_traffic(+ upstream: &[u8],+ message_id: &str,+ model: &str,+ traffic: Option<&TrafficCapture>,+) -> anyhow::Result<Value> {+ let mut capture = traffic.map(TrafficCapture::stream_capture);+ let mut decoder = super::stream::SseDecoder::default();+ let events = match decoder.push(upstream) {+ Ok(events) => events,+ Err(error) => {+ if let Some(capture) = capture.as_mut() {+ capture.malformed("decoder", "malformed_sse");+ }+ finish_capture(capture.take(), traffic, "error");+ return Err(error);+ }+ };+ if let Some(capture) = capture.as_mut() {+ for event in events {+ match serde_json::from_str::<Value>(&event.data) {+ Ok(value) => capture.upstream_event(event.event.as_deref(), &value),+ Err(_) => capture.malformed("json", "malformed_event"),+ }+ }+ }+ if let Err(error) = decoder.finish() {+ if let Some(capture) = capture.as_mut() {+ capture.malformed("decoder", "incomplete_stream");+ }+ finish_capture(capture.take(), traffic, "error");+ return Err(error);+ }let mut blocks: Vec<Value> = Vec::new();let mut block_positions = HashMap::new();let mut stop = "end_turn".to_string();let mut input = 0;let mut output = 0;- for event in reduce_upstream_bytes(upstream)? {+ let reduced = match reduce_upstream_bytes(upstream) {+ Ok(events) => events,+ Err(error) => {+ if let Some(capture) = capture.as_mut() {+ capture.malformed("reducer", "invalid_event");+ }+ finish_capture(capture.take(), traffic, "error");+ return Err(error);+ }+ };+ for event in reduced {match event {ReducerEvent::ThinkingStart(index) => {block_positions.insert(index, blocks.len());@@ -67,7 +114,16 @@ pub fn accumulate_response(.and_then(|position| blocks.get_mut(*position)){let raw = block.get("_args").and_then(Value::as_str).unwrap_or("{}");- block["input"] = serde_json::from_str(raw)?;+ match serde_json::from_str(raw) {+ Ok(input) => block["input"] = input,+ Err(error) => {+ if let Some(capture) = capture.as_mut() {+ capture.malformed("reducer", "invalid_tool_arguments");+ }+ finish_capture(capture.take(), traffic, "error");+ return Err(error.into());+ }+ }block.as_object_mut().unwrap().remove("_args");}}@@ -83,9 +139,25 @@ pub fn accumulate_response(_ => {}}}- Ok(- serde_json::json!({"id":message_id,"type":"message","role":"assistant","model":model,"content":blocks,"stop_reason":stop,"stop_sequence":null,"usage":{"input_tokens":input,"output_tokens":output}}),- )+ let response = serde_json::json!({"id":message_id,"type":"message","role":"assistant","model":model,"content":blocks,"stop_reason":stop,"stop_sequence":null,"usage":{"input_tokens":input,"output_tokens":output}});+ if let Some(mut capture) = capture {+ capture.downstream_event("response", response.clone());+ finish_capture(Some(capture), traffic, "completed");+ }+ Ok(response)+}++fn finish_capture(+ capture: Option<crate::traffic::StreamTrafficCapture>,+ traffic: Option<&TrafficCapture>,+ outcome: &str,+) {+ if let (Some(capture), Some(traffic)) = (capture, traffic) {+ capture.finish(+ traffic,+ serde_json::json!({"kind":"non_streaming","outcome":outcome}),+ );+ }}#[cfg(test)]diff --git a/src/traffic.rs b/src/traffic.rsindex 635ca62..780d2b8 100644--- a/src/traffic.rs+++ b/src/traffic.rs@@ -15,6 +15,11 @@ pub struct TrafficCapture {event_counter: Mutex<usize>,}+pub const MAX_SSE_CAPTURE_BYTES: usize = 8 * 1024 * 1024;+pub const MAX_STREAM_CAPTURE_EVENT_BYTES: usize = 8 * 1024 * 1024;+pub const MAX_STREAM_CAPTURE_EVENTS: usize = 1_024;+pub const MAX_STREAM_CAPTURE_FRAME_BYTES: usize = 64 * 1024;+#[derive(Debug)]pub struct TrafficCaptureOptions {pub req_id: String,@@ -98,6 +103,10 @@ impl TrafficCapture {let _ = write_bytes(path, &payload);}+ pub fn stream_capture(&self) -> StreamTrafficCapture {+ StreamTrafficCapture::default()+ }+fn next_artifact_path(&self, name: &str, ensure_ext_json: bool) -> PathBuf {let mut counter: MutexGuard<'_, usize> = self.artifact_counter@@ -130,6 +139,15 @@ impl TrafficCapture {}}+#[cfg(test)]+pub(crate) fn test_capture(root: PathBuf) -> TrafficCapture {+ TrafficCapture {+ root,+ artifact_counter: Mutex::new(0),+ event_counter: Mutex::new(0),+ }+}+fn write_bytes(path: PathBuf, value: &[u8]) -> io::Result<()> {if let Some(parent) = path.parent() {create_dir_all(parent)?;@@ -148,7 +166,6 @@ fn write_bytes(path: PathBuf, value: &[u8]) -> io::Result<()> {}let mut out = File::create(&path)?;out.write_all(value)?;- out.sync_all()?;#[cfg(unix)]{use std::os::unix::fs::PermissionsExt;@@ -159,6 +176,149 @@ fn write_bytes(path: PathBuf, value: &[u8]) -> io::Result<()> {Ok(())}+pub struct StreamTrafficCapture {+ upstream_sse: Vec<u8>,+ upstream_events: Vec<Value>,+ downstream_events: Vec<Value>,+ malformed: Vec<Value>,+ upstream_event_bytes: usize,+ downstream_event_bytes: usize,+ upstream_sse_truncated: u64,+ upstream_events_truncated: u64,+ downstream_events_truncated: u64,+ malformed_truncated: u64,+ upstream_frames_truncated: u64,+}++impl Default for StreamTrafficCapture {+ fn default() -> Self {+ Self {+ upstream_sse: Vec::with_capacity(MAX_SSE_CAPTURE_BYTES.min(64 * 1024)),+ upstream_events: Vec::new(),+ downstream_events: Vec::new(),+ malformed: Vec::new(),+ upstream_event_bytes: 0,+ downstream_event_bytes: 0,+ upstream_sse_truncated: 0,+ upstream_events_truncated: 0,+ downstream_events_truncated: 0,+ malformed_truncated: 0,+ upstream_frames_truncated: 0,+ }+ }+}++impl StreamTrafficCapture {+ pub fn upstream_event(&mut self, event: Option<&str>, value: &Value) {+ let value = redact_traffic(value);+ let frame = serde_json::to_vec(&value).unwrap_or_default();+ let event = event.unwrap_or("message");+ let frame_len = event.len().saturating_add(frame.len()).saturating_add(16);+ if frame_len > MAX_STREAM_CAPTURE_FRAME_BYTES {+ self.upstream_frames_truncated = self.upstream_frames_truncated.saturating_add(1);+ } else if self.upstream_sse.len().saturating_add(frame_len) <= MAX_SSE_CAPTURE_BYTES {+ self.upstream_sse.extend_from_slice(b"event: ");+ self.upstream_sse.extend_from_slice(event.as_bytes());+ self.upstream_sse.extend_from_slice(b"\ndata: ");+ self.upstream_sse.extend_from_slice(&frame);+ self.upstream_sse.extend_from_slice(b"\n\n");+ } else {+ self.upstream_sse_truncated = self.upstream_sse_truncated.saturating_add(1);+ }+ self.push_event(true, serde_json::json!({"event":event,"data":value}));+ }++ pub fn malformed(&mut self, stage: &str, kind: &str) {+ if self.malformed.len() < MAX_STREAM_CAPTURE_EVENTS {+ self.malformed+ .push(serde_json::json!({"stage":stage,"kind":kind}));+ } else {+ self.malformed_truncated = self.malformed_truncated.saturating_add(1);+ }+ }++ pub fn downstream_event(&mut self, event: &str, data: Value) {+ self.push_event(+ false,+ serde_json::json!({"event":event,"data":redact_traffic(&data)}),+ );+ }++ fn push_event(&mut self, upstream: bool, value: Value) {+ let bytes = serde_json::to_vec(&value).map_or(0, |value| value.len());+ let (events, total, truncated) = if upstream {+ (+ &mut self.upstream_events,+ &mut self.upstream_event_bytes,+ &mut self.upstream_events_truncated,+ )+ } else {+ (+ &mut self.downstream_events,+ &mut self.downstream_event_bytes,+ &mut self.downstream_events_truncated,+ )+ };+ if events.len() < MAX_STREAM_CAPTURE_EVENTS+ && total.saturating_add(bytes) <= MAX_STREAM_CAPTURE_EVENT_BYTES+ {+ *total += bytes;+ events.push(value);+ } else {+ *truncated = truncated.saturating_add(1);+ }+ }++ pub fn finish(self, traffic: &TrafficCapture, completion: Value) {+ let upstream_event_count = self.upstream_events.len();+ let downstream_event_count = self.downstream_events.len();+ if !self.upstream_sse.is_empty() {+ traffic.write_bytes("032-upstream-response-body.sse", &self.upstream_sse);+ }+ traffic.write_json(+ "033-upstream-response-capture",+ &serde_json::json!({+ "truncated": self.upstream_sse_truncated > 0 || self.upstream_frames_truncated > 0 || self.upstream_events_truncated > 0,+ "captured_bytes": self.upstream_sse.len(),+ "truncated_frames": self.upstream_sse_truncated,+ "oversized_frames": self.upstream_frames_truncated,+ "captured_events": self.upstream_events.len(),+ "captured_event_bytes": self.upstream_event_bytes,+ "truncated_events": self.upstream_events_truncated,+ "malformed": self.malformed,+ "truncated_malformed": self.malformed_truncated,+ }),+ );+ for value in self.upstream_events {+ traffic.write_json_event("040-upstream-event", &value);+ }+ for value in self.downstream_events {+ traffic.write_json_event("050-downstream-event", &value);+ }+ traffic.write_json(+ "061-grok-stream-summary",+ &serde_json::json!({+ "completion": completion,+ "upstream_sse": {+ "captured_bytes": self.upstream_sse.len(),+ "truncated_frames": self.upstream_sse_truncated,+ "oversized_frames": self.upstream_frames_truncated,+ },+ "upstream_events": {+ "captured": upstream_event_count,+ "captured_bytes": self.upstream_event_bytes,+ "truncated": self.upstream_events_truncated,+ },+ "downstream_events": {+ "captured": downstream_event_count,+ "captured_bytes": self.downstream_event_bytes,+ "truncated": self.downstream_events_truncated,+ },+ }),+ );+ }+}+pub fn sanitize_path_part(input: &str) -> String {let cleaned: String = input.chars()@@ -196,7 +356,27 @@ fn redact_traffic_with_depth(value: &Value, depth: u16) -> Value {Value::Object(map) => {let mut out = Map::new();for (key, value) in map {- if REDACT_KEYS.contains(&key.to_lowercase().as_str()) {+ let normalized = key.to_lowercase();+ if REDACT_KEYS.contains(&normalized.as_str())+ || matches!(+ normalized.as_str(),+ "token"+ | "bearer_token"+ | "oauth_token"+ | "oauth_access_token"+ | "oauth_refresh_token"+ | "client_secret"+ | "secret"+ | "password"+ | "email"+ | "user_id"+ | "account_id"+ | "identity"+ | "identity_id"+ | "subject"+ | "sub"+ )+ {out.insert(key.clone(), redact_traffic_value(value));} else {out.insert(key.clone(), redact_traffic_with_depth(value, depth + 1));diff --git a/tests/foundation.rs b/tests/foundation.rsindex dd044fc..86366e6 100644--- a/tests/foundation.rs+++ b/tests/foundation.rs@@ -7,8 +7,8 @@ use claude_code_proxy::logging::{create_logger, redact_value};use claude_code_proxy::paths::{self, DirResolverEnv};use claude_code_proxy::retry::{RETRY_INITIAL_DELAY_MS, RETRY_MAX_DELAY_MS, compute_backoff_delay};use claude_code_proxy::traffic::{- TrafficCaptureOptions, create_traffic_capture, redact_traffic, sanitize_path_part,- traffic_capture_enabled_for_env,+ MAX_SSE_CAPTURE_BYTES, TrafficCaptureOptions, create_traffic_capture, redact_traffic,+ sanitize_path_part, traffic_capture_enabled_for_env,};use serde_json::Map;use serde_json::json;@@ -136,6 +136,26 @@ fn traffic_capture_helpers() {.unwrap().contains("redacted"));+ assert_eq!(+ redact_traffic(&json!({"user_id":"person","note":"Bearer secret"}))["user_id"],+ "[redacted len=6]"+ );+ let secrets = json!({+ "access_token":"access-secret",+ "nested":[{"refresh_token":"refresh-secret","oauth_token":"oauth-secret"}],+ "identity":{"email":"[email protected]"},+ "user":{"message":"Bearer text is ordinary message content"}+ });+ let redacted = redact_traffic(&secrets).to_string();+ for secret in [+ "access-secret",+ "refresh-secret",+ "oauth-secret",+ "[email protected]",+ ] {+ assert!(!redacted.contains(secret));+ }+ assert!(redacted.contains("Bearer text is ordinary message content"));unsafe {env::set_var("CCP_TRAFFIC_LOG", "1");@@ -152,6 +172,27 @@ fn traffic_capture_helpers() {capture.write_text("020-note", "hello");capture.write_json("030-req", &json!({"token":"abc"}));+ let event = json!({"type":"response.completed","refresh_token":"secret"});+ let mut stream_capture = capture.stream_capture();+ for _ in 0..(MAX_SSE_CAPTURE_BYTES / 100 + 2) {+ stream_capture.upstream_event(Some("response.completed"), &event);+ }+ stream_capture.finish(&capture, json!({"kind":"test"}));+ let transcript = std::fs::read_to_string(+ std::fs::read_dir(capture.root())+ .unwrap()+ .find_map(|entry| {+ let path = entry.ok()?.path();+ path.file_name()?+ .to_string_lossy()+ .ends_with("032-upstream-response-body.sse")+ .then_some(path)+ })+ .unwrap(),+ )+ .unwrap();+ assert!(transcript.len() <= MAX_SSE_CAPTURE_BYTES);+ assert!(!transcript.contains("secret"));unsafe {env::remove_var("CCP_TRAFFIC_LOG");}