Skip to content

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.rs
index 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.rs
index 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>>,
) -> Response
where
S: Stream<Item = Result<Bytes, client::GrokError>> + Unpin + Send + 'static,
@@ -208,6 +228,8 @@ where
req_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 @@ where
loop {
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",
+ ] {
+ 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.rs
index 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.rs
index 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.rs
index 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",
+ ] {
+ 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");
}