Skip to content

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

Rust
18.2 KB
Raw Blame
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"));
    }
}