Skip to content

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

Rust

fix Grok long stream failures

Raine Virtaf5393de9d66f
diff --git a/src/providers/grok/client.rs b/src/providers/grok/client.rs
index 6d9a6f0..81e643f 100644
--- a/src/providers/grok/client.rs
+++ b/src/providers/grok/client.rs
@@ -69,7 +69,10 @@ impl GrokClient {
reqwest::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.connect_timeout(Duration::from_secs(10))
- .timeout(Duration::from_secs(120))
+ .tcp_nodelay(true)
+ .http2_keep_alive_interval(Duration::from_secs(15))
+ .http2_keep_alive_timeout(Duration::from_secs(5))
+ .http2_keep_alive_while_idle(true)
.build()?,
);
let auth = Arc::new(GrokAuthManager::new(file_store())?);
diff --git a/src/providers/grok/mod.rs b/src/providers/grok/mod.rs
index 94eb93c..aea839e 100644
--- a/src/providers/grok/mod.rs
+++ b/src/providers/grok/mod.rs
@@ -353,6 +353,13 @@ where
fn fail_at(&mut self, stage: &str, kind: &str) -> Vec<u8> {
self.error_sent = true;
+ let mut fields = serde_json::Map::new();
+ fields.insert("reqId".into(), serde_json::json!(self.req_id));
+ fields.insert("stage".into(), serde_json::json!(stage));
+ fields.insert("kind".into(), serde_json::json!(kind));
+ fields.insert("bytes".into(), serde_json::json!(self.bytes));
+ fields.insert("chunks".into(), serde_json::json!(self.chunks));
+ crate::logging::create_logger("grok").warn("grok_stream_failed", Some(fields));
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"}}));
@@ -627,6 +634,32 @@ mod tests {
);
}
+ #[tokio::test]
+ async fn data_less_upstream_frame_does_not_interrupt_stream() {
+ let upstream = futures_util::stream::iter(vec![
+ Ok(Bytes::from_static(
+ b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"first\"}\n\n",
+ )),
+ Ok(Bytes::from_static(b": keepalive\n\n")),
+ Ok(Bytes::from_static(
+ b"data: {\"type\":\"response.completed\",\"response\":{\"usage\":{}}}\n\n",
+ )),
+ ]);
+ let response = stream_body(
+ upstream,
+ "msg_1".into(),
+ "grok-4.5".into(),
+ None,
+ "req_1".into(),
+ None,
+ );
+ let body = response.into_body().collect().await.unwrap().to_bytes();
+ let body = String::from_utf8(body.to_vec()).unwrap();
+ assert!(body.contains("first"));
+ assert!(body.contains("event: message_stop"));
+ assert!(!body.contains("event: error"));
+ }
+
#[tokio::test]
async fn dropped_downstream_body_finalizes_partial_capture() {
let temp = TempDir::new().unwrap();
diff --git a/src/providers/grok/translate/accumulate.rs b/src/providers/grok/translate/accumulate.rs
index ff6549c..8ce62e9 100644
--- a/src/providers/grok/translate/accumulate.rs
+++ b/src/providers/grok/translate/accumulate.rs
@@ -209,4 +209,13 @@ mod tests {
assert_eq!(response["content"][0]["input"]["value"], 1);
assert_eq!(response["content"][1]["input"]["value"], 2);
}
+
+ #[test]
+ fn accumulate_response_ignores_data_less_frames() {
+ let input = b": keepalive\n\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"complete\"}\n\nid: 42\n\ndata: {\"type\":\"response.completed\",\"response\":{}}\n\n";
+ let response = accumulate_response(input, "message", "grok-4.5").unwrap();
+
+ assert_eq!(response["content"][0]["text"], "complete");
+ assert_eq!(response["stop_reason"], "end_turn");
+ }
}
diff --git a/src/providers/grok/translate/reducer.rs b/src/providers/grok/translate/reducer.rs
index ff8677c..e0b8648 100644
--- a/src/providers/grok/translate/reducer.rs
+++ b/src/providers/grok/translate/reducer.rs
@@ -60,7 +60,7 @@ impl Reducer {
.and_then(Value::as_str)
.ok_or_else(|| anyhow::anyhow!("event lacks type"))?;
match typ {
- "response.created" | "response.in_progress" => Ok(vec![]),
+ "response.created" | "response.in_progress" | "response.doom_loop_check" => Ok(vec![]),
"response.reasoning_summary_part.added"
| "response.reasoning_summary_part.done"
| "response.content_part.added" => Ok(vec![]),
@@ -332,7 +332,7 @@ impl Reducer {
_ => Ok(vec![]),
}
}
- "response.completed" => {
+ "response.completed" | "response.incomplete" => {
if !self.calls.is_empty() {
anyhow::bail!("function call is incomplete");
}
@@ -347,7 +347,9 @@ impl Reducer {
.get("output_tokens")
.and_then(Value::as_u64)
.unwrap_or(0);
- let stop = if self.saw_tool {
+ let stop = if typ == "response.incomplete" {
+ "max_tokens"
+ } else if self.saw_tool {
"tool_use"
} else {
"end_turn"
@@ -491,6 +493,26 @@ mod tests {
assert!(matches!(events.last(), Some(ReducerEvent::Finish { .. })));
}
+ #[test]
+ fn grok_reducer_ignores_doom_loop_check_and_accepts_incomplete() {
+ let input = b"data: {\"type\":\"response.doom_loop_check\",\"doom_loop_check\":{\"triggers\":[]}}\n\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"partial\"}\n\ndata: {\"type\":\"response.incomplete\",\"response\":{\"usage\":{\"input_tokens\":4,\"output_tokens\":2},\"incomplete_details\":{\"reason\":\"max_output_tokens\"}}}\n\n";
+ let events = reduce_upstream_bytes(input).unwrap();
+ assert!(
+ events.iter().any(
+ |event| matches!(event, ReducerEvent::TextDelta(_, delta) if delta == "partial")
+ )
+ );
+ assert!(matches!(
+ events.last(),
+ Some(ReducerEvent::Finish {
+ stop_reason,
+ input_tokens: 4,
+ output_tokens: 2,
+ ..
+ }) if stop_reason == "max_tokens"
+ ));
+ }
+
#[test]
fn grok_reducer_accepts_complete_observed_lifecycle() {
let input = b"data: {\"type\":\"response.created\"}\n\ndata: {\"type\":\"response.in_progress\"}\n\ndata: {\"type\":\"response.reasoning_summary_part.added\"}\n\ndata: {\"type\":\"response.reasoning_summary_text.delta\",\"delta\":\"think\"}\n\ndata: {\"type\":\"response.reasoning_summary_text.done\"}\n\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\"}}\n\ndata: {\"type\":\"response.content_part.added\"}\n\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"answer\"}\n\ndata: {\"type\":\"response.output_text.done\"}\n\ndata: {\"type\":\"response.content_part.done\"}\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.function_call_arguments.done\",\"call_id\":\"call_1\",\"arguments\":\"{}\"}\n\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"function_call\",\"call_id\":\"call_1\"}}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"usage\":{\"input_tokens\":4,\"output_tokens\":2}}}\n\n";
diff --git a/src/providers/grok/translate/stream.rs b/src/providers/grok/translate/stream.rs
index 62d0034..1f6706c 100644
--- a/src/providers/grok/translate/stream.rs
+++ b/src/providers/grok/translate/stream.rs
@@ -50,8 +50,10 @@ impl SseDecoder {
fn end_line(&mut self, events: &mut Vec<SseEvent>) -> anyhow::Result<()> {
if self.frame.len() == self.line_start {
- if !self.frame.is_empty() {
- events.push(parse_frame(&self.frame)?);
+ if !self.frame.is_empty()
+ && let Some(event) = parse_frame(&self.frame)?
+ {
+ events.push(event);
}
self.frame.clear();
self.line_start = 0;
@@ -63,7 +65,7 @@ impl SseDecoder {
}
}
-fn parse_frame(frame: &[u8]) -> anyhow::Result<SseEvent> {
+fn parse_frame(frame: &[u8]) -> anyhow::Result<Option<SseEvent>> {
let frame = std::str::from_utf8(frame)
.map_err(|_| anyhow::anyhow!("Grok SSE frame contains invalid UTF-8"))?;
let mut event = None;
@@ -81,12 +83,12 @@ fn parse_frame(frame: &[u8]) -> anyhow::Result<SseEvent> {
}
}
if data.is_empty() {
- anyhow::bail!("Grok SSE frame lacks data")
+ return Ok(None);
}
- Ok(SseEvent {
+ Ok(Some(SseEvent {
event,
data: data.join("\n"),
- })
+ }))
}
pub struct StreamTranslator {
@@ -330,6 +332,22 @@ mod tests {
}
}
+ #[test]
+ fn decoder_ignores_data_less_frames_at_every_boundary() {
+ let input = b": keepalive\n\nid: 42\n\nevent: ignored\n\nretry: 5000\n\ndata: complete\n\n";
+ let expected = vec![SseEvent {
+ event: None,
+ data: "complete".into(),
+ }];
+ for split in 0..=input.len() {
+ let mut decoder = SseDecoder::default();
+ let mut events = decoder.push(&input[..split]).unwrap();
+ events.extend(decoder.push(&input[split..]).unwrap());
+ decoder.finish().unwrap();
+ assert_eq!(events, expected);
+ }
+ }
+
#[test]
fn decoder_requires_terminated_valid_frames_and_bounds_them() {
assert!(SseDecoder::default().push(b"data: \xff\n\n").is_err());