Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
use std::convert::Infallible;
use std::sync::Arc;
use axum::body::Body;
use bytes::Bytes;
use futures_util::StreamExt;
use crate::anthropic::schema::MessagesRequest;
use crate::monitor::{MonitorHandle, usage_from_anthropic_sse};
use crate::providers::codex::translate::{
IncompleteResponsePolicy, accumulate::accumulate_response_with_policy,
live_stream::LiveStreamTranslator, request::translate_openai_compatible_request,
};
use crate::providers::grok::translate::stream::SseDecoder;
use crate::traffic::{StreamTrafficCapture, TrafficCapture};
use super::client::{OpenCodeError, OpenCodeResponse};
pub fn prepare_request(
body: &MessagesRequest,
model: &str,
session_id: Option<String>,
) -> anyhow::Result<serde_json::Value> {
let translated = translate_openai_compatible_request(body, model.to_string(), session_id)?;
let mut value = serde_json::to_value(translated)?;
if let Some(max_tokens) = body.max_tokens.filter(|value| *value > 0) {
value["max_output_tokens"] = serde_json::json!(max_tokens);
}
Ok(value)
}
pub fn accumulate_response(
upstream: &[u8],
message_id: &str,
model: &str,
) -> anyhow::Result<serde_json::Value> {
accumulate_response_with_policy(
upstream,
message_id,
model,
IncompleteResponsePolicy::AllowMaxOutputTokens,
)
}
pub fn stream_body(
upstream: OpenCodeResponse,
message_id: String,
model: String,
monitor: Option<MonitorHandle>,
req_id: String,
traffic: Option<Arc<TrafficCapture>>,
) -> Body {
let state = ResponsesStreamState {
upstream: upstream.into_stream(),
decoder: SseDecoder::default(),
translator: LiveStreamTranslator::new(message_id, model)
.with_incomplete_response_policy(IncompleteResponsePolicy::AllowMaxOutputTokens),
pending_completion: None,
done_seen: false,
terminal: false,
error_sent: false,
monitor,
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
.next_output()
.await
.map(|bytes| (Ok::<Bytes, Infallible>(Bytes::from(bytes)), state))
});
Body::from_stream(stream)
}
struct ResponsesStreamState<S> {
upstream: S,
decoder: SseDecoder,
translator: LiveStreamTranslator,
pending_completion: Option<serde_json::Value>,
done_seen: bool,
terminal: bool,
error_sent: bool,
monitor: Option<MonitorHandle>,
req_id: String,
bytes: u64,
chunks: u64,
stream_capture: Option<StreamTrafficCapture>,
traffic: Option<Arc<TrafficCapture>>,
}
impl<S> ResponsesStreamState<S>
where
S: futures_util::Stream<Item = Result<Bytes, OpenCodeError>> + Unpin,
{
async fn next_output(&mut self) -> Option<Vec<u8>> {
if self.terminal {
return None;
}
if self.error_sent {
self.terminal = true;
return None;
}
loop {
let chunk = match self.upstream.next().await {
Some(Ok(chunk)) => chunk,
Some(Err(_)) => return Some(self.fail_at("transport", "upstream_stream")),
None => {
if self.decoder.finish().is_err() {
return Some(self.fail_at("decoder", "incomplete_stream"));
}
let Some(completion) = self.pending_completion.take() else {
return Some(self.fail_at("decoder", "incomplete_stream"));
};
let output = match self.translator.accept(&completion, self.traffic.as_deref())
{
Ok(output) => output,
Err(_) => return Some(self.fail_at("translation", "invalid_event")),
};
self.terminal = true;
self.record_progress(&output);
self.capture_downstream(&output);
self.finish_capture(true);
return (!output.is_empty()).then_some(output);
}
};
if self.bytes == 0
&& let Some(monitor) = self.monitor.as_ref()
{
monitor.generation_started(&self.req_id);
}
self.bytes = self.bytes.saturating_add(chunk.len() as u64);
self.chunks = self.chunks.saturating_add(1);
let events = match self.decoder.push(&chunk) {
Ok(events) => events,
Err(_) => return Some(self.fail_at("decoder", "malformed_sse")),
};
let mut output = Vec::new();
for event in events {
let data = event.data.trim();
if data == "[DONE]" {
if self.pending_completion.is_none() || self.done_seen {
return Some(self.fail_at("protocol", "premature_done"));
}
self.done_seen = true;
if let Some(capture) = self.stream_capture.as_mut() {
capture
.upstream_event(event.event.as_deref(), &serde_json::json!("[DONE]"));
}
continue;
}
let value: serde_json::Value = match serde_json::from_str(data) {
Ok(value) => value,
Err(_) => 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 event_type = value.get("type").and_then(serde_json::Value::as_str);
if self.pending_completion.is_some() {
if event_type == Some("ping") {
continue;
}
return Some(self.fail_at("protocol", "event_after_completion"));
}
if matches!(
event_type,
Some("response.completed" | "response.incomplete" | "response.done")
) {
// Keep the translator open until EOF so invalid tails can emit an error.
self.pending_completion = Some(value);
continue;
}
let translated = match self.translator.accept(&value, self.traffic.as_deref()) {
Ok(translated) => translated,
Err(_) => return Some(self.fail_at("translation", "invalid_event")),
};
output.extend(translated);
}
if !output.is_empty() {
self.record_progress(&output);
self.capture_downstream(&output);
return Some(output);
}
}
}
fn record_progress(&self, output: &[u8]) {
let Some(monitor) = self.monitor.as_ref() else {
return;
};
let (input_tokens, output_tokens) = usage_from_anthropic_sse(output);
monitor.stream_progress(
&self.req_id,
output.len() as u64,
count_sse_events(output),
input_tokens,
output_tokens,
);
}
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);
}
if let Some(traffic) = self.traffic.as_ref() {
traffic.write_json(
"060-opencode-responses-stream-error",
&serde_json::json!({
"stage": stage,
"kind": kind,
"bytes": self.bytes,
"chunks": self.chunks,
}),
);
}
let output = self.translator.error_chunk(
"OpenCode Go Responses stream is invalid",
"api_error",
self.traffic.as_deref(),
);
self.capture_downstream(&output);
self.finish_capture(false);
output
}
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(value) = serde_json::from_str(&event.data) {
capture.downstream_event(event.event.as_deref().unwrap_or("message"), value);
}
}
}
}
fn finish_capture(&mut self, completed: bool) {
if let (Some(capture), Some(traffic)) = (self.stream_capture.take(), self.traffic.as_ref())
{
capture.finish_named(
traffic,
serde_json::json!({
"kind": if completed { "stream_completion" } else { "stream_error" },
"bytes": self.bytes,
"chunks": self.chunks,
}),
"061-opencode-responses-stream-summary",
);
}
}
}
impl<S> Drop for ResponsesStreamState<S> {
fn drop(&mut self) {
if self.terminal || self.stream_capture.is_none() {
return;
}
if let (Some(capture), Some(traffic)) = (self.stream_capture.take(), self.traffic.as_ref())
{
capture.finish_named(
traffic,
serde_json::json!({
"kind": "stream_abandoned",
"reason": "downstream_body_dropped",
"bytes": self.bytes,
"chunks": self.chunks,
}),
"061-opencode-responses-stream-summary",
);
}
}
}
fn count_sse_events(bytes: &[u8]) -> u64 {
String::from_utf8_lossy(bytes).matches("event:").count() as u64
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
const COMPLETION: &str = "data: {\"type\":\"response.completed\",\"response\":{\"usage\":{\"input_tokens\":1,\"output_tokens\":1}}}\n\n";
const PING: &str = "event: ping\ndata: {\"type\":\"ping\",\"cost\":\"0\"}\n\n";
fn test_state<S>(upstream: S) -> ResponsesStreamState<S> {
ResponsesStreamState {
upstream,
decoder: SseDecoder::default(),
translator: LiveStreamTranslator::new("msg_1", "gpt-5.6-luna"),
pending_completion: None,
done_seen: false,
terminal: false,
error_sent: false,
monitor: None,
req_id: "req".into(),
bytes: 0,
chunks: 0,
stream_capture: None,
traffic: None,
}
}
#[tokio::test]
async fn completion_tail_is_independent_of_chunk_boundaries() {
let wire = format!("{COMPLETION}{PING}data: [DONE]\n\n{PING}");
for split in 0..=wire.len() {
let upstream = futures_util::stream::iter([
Ok(Bytes::copy_from_slice(&wire.as_bytes()[..split])),
Ok(Bytes::copy_from_slice(&wire.as_bytes()[split..])),
]);
let mut state = test_state(upstream);
let output = state.next_output().await.unwrap();
let text = String::from_utf8_lossy(&output);
assert!(text.contains("message_stop"), "split {split}: {text}");
assert!(!text.contains("api_error"), "split {split}: {text}");
assert_eq!(state.chunks, 2);
assert!(state.next_output().await.is_none());
}
}
#[tokio::test]
async fn invalid_tails_are_rejected_across_chunks() {
for tail in [
COMPLETION,
"data: {\"type\":\"response.done\"}\n\n",
"data: {\"type\":\"response.incomplete\"}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"delta\":\"late\"}\n\n",
"data: not-json\n\n",
"event: ping\ndata: {\"",
"data: [DONE]\n\ndata: [DONE]\n\n",
"data: [DONE]\n\ndata: {\"type\":\"response.completed\"}\n\n",
] {
let wire = format!("{COMPLETION}{tail}");
for split in 0..=wire.len() {
let mut state = test_state(futures_util::stream::iter([
Ok(Bytes::copy_from_slice(&wire.as_bytes()[..split])),
Ok(Bytes::copy_from_slice(&wire.as_bytes()[split..])),
]));
let output = state.next_output().await.unwrap();
let text = String::from_utf8_lossy(&output);
assert!(
text.contains("api_error"),
"tail {tail}, split {split}: {text}"
);
assert!(!text.contains("message_stop"));
assert!(state.next_output().await.is_none());
}
}
}
#[tokio::test]
async fn rejects_premature_done_and_transport_error_after_completion() {
for chunks in [
vec![Ok(Bytes::from_static(b"data: [DONE]\n\n"))],
vec![
Ok(Bytes::from_static(COMPLETION.as_bytes())),
Err(OpenCodeError {
status: http::StatusCode::BAD_GATEWAY,
retry_after: None,
message: "disconnected".into(),
}),
],
] {
let mut state = test_state(futures_util::stream::iter(chunks));
let output = state.next_output().await.unwrap();
assert!(String::from_utf8_lossy(&output).contains("api_error"));
assert!(state.next_output().await.is_none());
}
}
#[tokio::test]
async fn streams_text_before_completion_and_waits_for_eof_to_finish() {
let (sender, receiver) = tokio::sync::mpsc::channel(4);
let upstream = futures_util::stream::unfold(receiver, |mut receiver| async {
receiver.recv().await.map(|chunk| (chunk, receiver))
});
let mut state = test_state(Box::pin(upstream));
sender.send(Ok(Bytes::from_static(
b"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"early\"}\n\n",
))).await.unwrap();
let output = tokio::time::timeout(std::time::Duration::from_secs(1), state.next_output())
.await
.unwrap()
.unwrap();
assert!(String::from_utf8_lossy(&output).contains("early"));
sender
.send(Ok(Bytes::from_static(COMPLETION.as_bytes())))
.await
.unwrap();
assert!(
tokio::time::timeout(std::time::Duration::from_millis(20), state.next_output())
.await
.is_err()
);
sender
.send(Ok(Bytes::from_static(PING.as_bytes())))
.await
.unwrap();
drop(sender);
let output = state.next_output().await.unwrap();
assert!(String::from_utf8_lossy(&output).contains("message_stop"));
assert!(state.next_output().await.is_none());
}
#[test]
fn request_uses_standard_responses_fields_without_codex_lane_metadata() {
let body: MessagesRequest = serde_json::from_value(json!({
"model": "opencode-go/gpt-5.6-luna",
"max_tokens": 2048,
"output_config": {"effort": "xhigh"},
"messages": [{"role": "user", "content": "hello"}]
}))
.unwrap();
let translated = prepare_request(&body, "gpt-5.6-luna", Some("session-1".into()))
.expect("translate Responses request");
assert_eq!(translated["model"], "gpt-5.6-luna");
assert_eq!(translated["stream"], true);
assert_eq!(translated["max_output_tokens"], 2048);
assert_eq!(translated["reasoning"]["effort"], "xhigh");
assert_eq!(translated["reasoning"]["summary"], "auto");
assert_eq!(translated["prompt_cache_key"], "session-1");
assert!(translated.get("service_tier").is_none());
assert!(translated.get("client_metadata").is_none());
}
#[tokio::test]
async fn live_stream_rejects_an_incomplete_frame_after_completion() {
let upstream = futures_util::stream::iter([Ok::<Bytes, OpenCodeError>(
Bytes::from_static(
b"data: {\"type\":\"response.completed\",\"response\":{\"usage\":{\"input_tokens\":1,\"output_tokens\":1}}}\n\ndata: {",
),
)]);
let mut state = ResponsesStreamState {
upstream,
decoder: SseDecoder::default(),
translator: LiveStreamTranslator::new("msg_1", "gpt-5.6-luna"),
pending_completion: None,
done_seen: false,
terminal: false,
error_sent: false,
monitor: None,
req_id: "req".into(),
bytes: 0,
chunks: 0,
stream_capture: None,
traffic: None,
};
let output = state.next_output().await.expect("error event");
assert!(
String::from_utf8_lossy(&output).contains("OpenCode Go Responses stream is invalid")
);
}
#[tokio::test]
async fn live_stream_accepts_ping_after_completion() {
let upstream = futures_util::stream::iter([Ok::<Bytes, OpenCodeError>(
Bytes::from_static(
b"data: {\"type\":\"response.completed\",\"response\":{\"usage\":{\"input_tokens\":1,\"output_tokens\":1}}}\n\nevent: ping\ndata: {\"type\":\"ping\",\"cost\":\"0\"}\n\n",
),
)]);
let mut state = ResponsesStreamState {
upstream,
decoder: SseDecoder::default(),
translator: LiveStreamTranslator::new("msg_1", "grok-4.6"),
pending_completion: None,
done_seen: false,
terminal: false,
error_sent: false,
monitor: None,
req_id: "req".into(),
bytes: 0,
chunks: 0,
stream_capture: None,
traffic: None,
};
let output = state.next_output().await.expect("completion event");
let text = String::from_utf8_lossy(&output);
assert!(text.contains("message_stop"));
assert!(!text.contains("OpenCode Go Responses stream is invalid"));
}
}