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.rsindex e166c74..8f63b2c 100644--- a/src/providers/grok/mod.rs+++ b/src/providers/grok/mod.rs@@ -389,7 +389,7 @@ whereif 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.rsindex 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.rsindex 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.rsindex 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: GrokSearchBlockx_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))+ );+ }}