Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

grok: keep absent input usage from becoming zero

Raine Virta01210549a91c
diff --git a/src/providers/grok/mod.rs b/src/providers/grok/mod.rs
index e166c74..8f63b2c 100644
--- a/src/providers/grok/mod.rs
+++ b/src/providers/grok/mod.rs
@@ -389,7 +389,7 @@ where
if let Some((input_tokens, output_tokens)) = usage
&& let Some(monitor) = self.monitor.as_ref()
{
- monitor.usage_updated(&self.req_id, Some(input_tokens), Some(output_tokens));
+ monitor.usage_updated(&self.req_id, input_tokens, Some(output_tokens));
}
if self.reducer.finished() {
self.terminal = true;
@@ -691,6 +691,59 @@ mod tests {
);
}
+ /// Streams one estimated response and returns the monitor's published
+ /// input and output usage. `None` means the field was never set.
+ async fn monitored_usage(completed_response: &str) -> (Option<u64>, Option<u64>) {
+ let monitor = MonitorHandle::new(10);
+ monitor.request_started("req_1", None, Some(1), EndpointKind::Messages);
+ monitor.provider_selected("req_1", "grok", "grok-4.5", None);
+ monitor.request_completed("req_1", 200, None, None);
+ let payload = format!(
+ "data: {{\"type\":\"response.output_text.delta\",\"delta\":\"ok\"}}\n\ndata: {{\"type\":\"response.completed\",\"response\":{completed_response}}}\n\n"
+ );
+ let upstream = futures_util::stream::iter(vec![Ok(Bytes::from(payload))]);
+ let response = stream_body(
+ upstream,
+ "msg_1".into(),
+ "grok-4.5".into(),
+ 321,
+ Some(monitor.clone()),
+ "req_1".into(),
+ None,
+ );
+ let _ = response.into_body().collect().await.unwrap();
+ let snapshot = monitor.snapshot();
+ let request = snapshot
+ .recent
+ .iter()
+ .find(|request| request.request_id == "req_1")
+ .unwrap();
+ (request.input_tokens, request.output_tokens)
+ }
+
+ #[tokio::test]
+ async fn missing_provider_input_usage_does_not_zero_the_monitor() {
+ assert_eq!(
+ monitored_usage("{\"usage\":{\"input_tokens\":12,\"output_tokens\":3}}").await,
+ (Some(12), Some(3))
+ );
+ // A provider-reported zero is preserved rather than treated as missing.
+ assert_eq!(
+ monitored_usage("{\"usage\":{\"input_tokens\":0,\"output_tokens\":3}}").await,
+ (Some(0), Some(3))
+ );
+ assert_eq!(
+ monitored_usage("{\"usage\":{\"output_tokens\":3}}").await,
+ (None, Some(3))
+ );
+ assert_eq!(monitored_usage("{\"usage\":{}}").await, (None, Some(0)));
+ assert_eq!(monitored_usage("{}").await, (None, Some(0)));
+ assert_eq!(
+ monitored_usage("{\"usage\":{\"input_tokens\":\"12\"}}").await,
+ (None, Some(0))
+ );
+ }
+
#[tokio::test]
async fn downstream_event_arrives_before_upstream_completion() {
let (tx, rx) = mpsc::channel(2);
diff --git a/src/providers/grok/translate/accumulate.rs b/src/providers/grok/translate/accumulate.rs
index c6c644d..9adc618 100644
--- a/src/providers/grok/translate/accumulate.rs
+++ b/src/providers/grok/translate/accumulate.rs
@@ -198,7 +198,11 @@ pub fn accumulate_response_with_options(
x_search_requests: x_requests,
} => {
stop = stop_reason;
- input = input_tokens;
+ // The non-streaming response always carries an input count, so
+ // a missing provider field falls back to zero here rather than
+ // dropping the key. The streaming path preserves absence
+ // instead, because it must not erase the seeded estimate.
+ input = input_tokens.unwrap_or(0);
output = output_tokens;
web_search_requests = web_requests;
x_search_requests = x_requests;
diff --git a/src/providers/grok/translate/reducer.rs b/src/providers/grok/translate/reducer.rs
index e0b8648..978d84d 100644
--- a/src/providers/grok/translate/reducer.rs
+++ b/src/providers/grok/translate/reducer.rs
@@ -28,7 +28,9 @@ pub enum ReducerEvent {
Citation(usize, Value),
Finish {
stop_reason: String,
- input_tokens: u64,
+ // `None` when the provider omitted, emptied, or malformed the input
+ // usage field. A present zero is a real provider-reported value.
+ input_tokens: Option<u64>,
output_tokens: u64,
web_search_requests: u64,
x_search_requests: u64,
@@ -339,10 +341,7 @@ impl Reducer {
let mut out = self.close_active()?;
let response = value.get("response").unwrap_or(&value);
let usage = response.get("usage").unwrap_or(&Value::Null);
- let input = usage
- .get("input_tokens")
- .and_then(Value::as_u64)
- .unwrap_or(0);
+ let input = usage.get("input_tokens").and_then(Value::as_u64);
let output = usage
.get("output_tokens")
.and_then(Value::as_u64)
@@ -506,7 +505,7 @@ mod tests {
events.last(),
Some(ReducerEvent::Finish {
stop_reason,
- input_tokens: 4,
+ input_tokens: Some(4),
output_tokens: 2,
..
}) if stop_reason == "max_tokens"
@@ -520,10 +519,44 @@ mod tests {
assert!(matches!(
events.last(),
Some(ReducerEvent::Finish {
- input_tokens: 4,
+ input_tokens: Some(4),
output_tokens: 2,
..
})
));
}
+
+ fn finish_input_tokens(response: &str) -> Option<u64> {
+ let input =
+ format!("data: {{\"type\":\"response.completed\",\"response\":{response}}}\n\n");
+ let events = reduce_upstream_bytes(input.as_bytes()).unwrap();
+ match events.last() {
+ Some(ReducerEvent::Finish { input_tokens, .. }) => *input_tokens,
+ other => panic!("expected a finish event, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn grok_reducer_preserves_input_usage_presence() {
+ assert_eq!(
+ finish_input_tokens("{\"usage\":{\"input_tokens\":4,\"output_tokens\":2}}"),
+ Some(4)
+ );
+ // A provider-reported zero stays a value, not a missing field.
+ assert_eq!(
+ finish_input_tokens("{\"usage\":{\"input_tokens\":0,\"output_tokens\":2}}"),
+ Some(0)
+ );
+ assert_eq!(finish_input_tokens("{\"usage\":{}}"), None);
+ assert_eq!(
+ finish_input_tokens("{\"usage\":{\"output_tokens\":2}}"),
+ None
+ );
+ assert_eq!(
+ finish_input_tokens("{\"usage\":{\"input_tokens\":\"4\"}}"),
+ None
+ );
+ // No usage object at all is also absent, not zero.
+ assert_eq!(finish_input_tokens("{}"), None);
+ }
}
diff --git a/src/providers/grok/translate/stream.rs b/src/providers/grok/translate/stream.rs
index ca80b54..b344484 100644
--- a/src/providers/grok/translate/stream.rs
+++ b/src/providers/grok/translate/stream.rs
@@ -384,10 +384,17 @@ fn render(out: &mut Vec<u8>, event: ReducerEvent, search_blocks: GrokSearchBlock
x_search_requests,
} => {
let hosted_search_requests = web_search_requests + x_search_requests;
+ // Emit input usage only when the provider actually reported it.
+ // Claude Code keeps the seeded message_start value when the field
+ // is absent, whereas a synthesized zero would erase the estimate.
+ let mut usage = serde_json::json!({"output_tokens":output_tokens,"server_tool_use":{"web_search_requests":hosted_search_requests,"x_search_requests":x_search_requests}});
+ if let Some(input_tokens) = input_tokens {
+ usage["input_tokens"] = serde_json::json!(input_tokens);
+ }
emit(
out,
"message_delta",
- serde_json::json!({"type":"message_delta","delta":{"stop_reason":stop_reason,"stop_sequence":null},"usage":{"input_tokens":input_tokens,"output_tokens":output_tokens,"server_tool_use":{"web_search_requests":hosted_search_requests,"x_search_requests":x_search_requests}}}),
+ serde_json::json!({"type":"message_delta","delta":{"stop_reason":stop_reason,"stop_sequence":null},"usage":usage}),
);
emit(
out,
@@ -618,4 +625,75 @@ mod tests {
Some(&serde_json::json!(3))
);
}
+
+ /// Renders one estimated stream and returns the input usage seeded at
+ /// `message_start`, plus the input and output usage published at
+ /// `message_delta`. `None` means the field was omitted downstream.
+ fn streamed_usage(completed_response: &str) -> (Option<u64>, Option<u64>, Option<u64>) {
+ let mut translator = LiveStreamTranslator::with_estimated_input_tokens(
+ "msg_1".into(),
+ "grok-4.5".into(),
+ 321,
+ );
+ let started = translator
+ .push(b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"ok\"}\n\n")
+ .unwrap();
+ let started = crate::anthropic::sse::parse_sse_events(&started)
+ .into_iter()
+ .filter_map(|event| serde_json::from_str::<serde_json::Value>(&event.data).ok())
+ .find(|value| {
+ value.get("type").and_then(serde_json::Value::as_str) == Some("message_start")
+ })
+ .unwrap();
+ let payload = format!(
+ "data: {{\"type\":\"response.completed\",\"response\":{completed_response}}}\n\n"
+ );
+ let finished = translator.push(payload.as_bytes()).unwrap();
+ let finished = crate::anthropic::sse::parse_sse_events(&finished)
+ .into_iter()
+ .filter_map(|event| serde_json::from_str::<serde_json::Value>(&event.data).ok())
+ .find(|value| {
+ value.get("type").and_then(serde_json::Value::as_str) == Some("message_delta")
+ })
+ .unwrap();
+ let value = |pointer: &str| {
+ finished
+ .pointer(pointer)
+ .and_then(serde_json::Value::as_u64)
+ };
+ (
+ started
+ .pointer("/message/usage/input_tokens")
+ .and_then(serde_json::Value::as_u64),
+ value("/usage/input_tokens"),
+ value("/usage/output_tokens"),
+ )
+ }
+
+ #[test]
+ fn missing_provider_input_usage_keeps_the_seeded_estimate() {
+ // Exact provider usage replaces the estimate.
+ assert_eq!(
+ streamed_usage("{\"usage\":{\"input_tokens\":12,\"output_tokens\":3}}"),
+ (Some(321), Some(12), Some(3))
+ );
+ // A provider-reported zero is a real value and replaces the estimate.
+ assert_eq!(
+ streamed_usage("{\"usage\":{\"input_tokens\":0,\"output_tokens\":3}}"),
+ (Some(321), Some(0), Some(3))
+ );
+ // Absent, empty, output-only, and non-numeric input usage must not
+ // publish a zero. The terminal delta omits the field so the client
+ // keeps the seeded estimate, while output usage still flows.
+ assert_eq!(streamed_usage("{\"usage\":{}}"), (Some(321), None, Some(0)));
+ assert_eq!(
+ streamed_usage("{\"usage\":{\"output_tokens\":3}}"),
+ (Some(321), None, Some(3))
+ );
+ assert_eq!(streamed_usage("{}"), (Some(321), None, Some(0)));
+ assert_eq!(
+ streamed_usage("{\"usage\":{\"input_tokens\":\"12\"}}"),
+ (Some(321), None, Some(0))
+ );
+ }
}