Skip to content

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

Rust
12.5 KB
Raw Blame
use std::sync::Arc;
use std::time::Duration;

use futures_util::StreamExt;
use http::StatusCode;
use serde::Serialize;

use super::model::EndpointKind;
use crate::traffic::TrafficCapture;

const MAX_BUFFERED_RESPONSE_BYTES: usize = 8 * 1024 * 1024;

pub struct OpenCodeClient {
    client: Arc<reqwest::Client>,
    base_url: reqwest::Url,
    api_key: Option<String>,
}

pub struct OpenCodeResponse {
    response: reqwest::Response,
}

#[derive(Debug)]
pub struct OpenCodeError {
    pub status: StatusCode,
    pub retry_after: Option<String>,
    pub message: String,
}

impl OpenCodeResponse {
    pub fn into_stream(
        self,
    ) -> impl futures_util::Stream<Item = Result<bytes::Bytes, OpenCodeError>> + Send {
        self.response.bytes_stream().map(|chunk| {
            chunk.map_err(|_| OpenCodeError {
                status: StatusCode::BAD_GATEWAY,
                retry_after: None,
                message: "OpenCode Go upstream stream failed".to_string(),
            })
        })
    }

    pub async fn into_bytes(self) -> Result<Vec<u8>, OpenCodeError> {
        let mut stream = self.into_stream();
        let mut bytes = Vec::new();
        while let Some(chunk) = stream.next().await {
            let chunk = chunk?;
            if bytes.len().saturating_add(chunk.len()) > MAX_BUFFERED_RESPONSE_BYTES {
                return Err(OpenCodeError {
                    status: StatusCode::BAD_GATEWAY,
                    retry_after: None,
                    message: "OpenCode Go upstream response exceeds the size limit".to_string(),
                });
            }
            bytes.extend_from_slice(&chunk);
        }
        Ok(bytes)
    }
}

impl OpenCodeClient {
    pub fn new(base_url: String, api_key: Option<String>) -> anyhow::Result<Self> {
        let base_url = reqwest::Url::parse(base_url.trim_end_matches('/'))?;
        let client = reqwest::Client::builder()
            .redirect(reqwest::redirect::Policy::none())
            .connect_timeout(Duration::from_secs(10))
            .build()?;
        Ok(Self {
            client: Arc::new(client),
            base_url,
            api_key,
        })
    }

    pub async fn post<T: Serialize + ?Sized>(
        &self,
        endpoint: EndpointKind,
        body: &T,
        stream: bool,
        traffic: Option<Arc<TrafficCapture>>,
        session_id: Option<&str>,
    ) -> Result<OpenCodeResponse, OpenCodeError> {
        let Some(api_key) = self.api_key.as_deref().filter(|key| !key.is_empty()) else {
            return Err(OpenCodeError {
                status: StatusCode::UNAUTHORIZED,
                retry_after: None,
                message: "OpenCode Go API key is not configured; set CCP_OPENCODE_API_KEY, OPENCODE_API_KEY, or opencode.apiKey in config.json".to_string(),
            });
        };
        let url = self.endpoint_url(endpoint);
        let accept = if stream {
            "text/event-stream"
        } else {
            "application/json"
        };

        let session_header_value = session_id
            .filter(|value| http::HeaderValue::from_str(value).is_ok())
            .map(str::to_string)
            .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());

        if let Some(capture) = traffic.as_ref() {
            let value = serde_json::to_value(body).unwrap_or(serde_json::Value::Null);
            capture.write_json("020-upstream-request", &value);
            let auth_header = match endpoint {
                EndpointKind::ChatCompletions | EndpointKind::Responses => "authorization",
                EndpointKind::Messages => "x-api-key",
            };
            capture.write_json(
                "021-upstream-request-metadata",
                &serde_json::json!({
                    "method": "POST",
                    "url": url.as_str(),
                    "provider": "opencode",
                    "transport": "http",
                    "headers": {
                        "accept": accept,
                        auth_header: "[redacted]",
                        "content-type": "application/json",
                        "x-opencode-session": session_header_value
                    }
                }),
            );
        }

        let mut request = self
            .client
            .post(url)
            .header(http::header::ACCEPT, accept)
            .header(http::header::CONTENT_TYPE, "application/json")
            .header("x-opencode-session", &session_header_value)
            .json(body);
        match endpoint {
            EndpointKind::ChatCompletions | EndpointKind::Responses => {
                request = request.header(http::header::AUTHORIZATION, format!("Bearer {api_key}"));
            }
            EndpointKind::Messages => {
                request = request
                    .header("x-api-key", api_key)
                    .header("anthropic-version", "2023-06-01");
            }
        }
        let response = request.send().await.map_err(|_| OpenCodeError {
            status: StatusCode::BAD_GATEWAY,
            retry_after: None,
            message: "OpenCode Go upstream request failed".to_string(),
        })?;

        if let Some(capture) = traffic.as_ref() {
            capture.write_json(
                "030-upstream-response-headers",
                &serde_json::json!({
                    "status": response.status().as_u16(),
                    "headers": safe_headers(response.headers())
                }),
            );
        }

        if !response.status().is_success() {
            return Err(rejected_response(response).await);
        }
        Ok(OpenCodeResponse { response })
    }

    fn endpoint_url(&self, endpoint: EndpointKind) -> reqwest::Url {
        let mut url = self.base_url.clone();
        let base_path = url.path().trim_end_matches('/');
        let suffix = match endpoint {
            EndpointKind::ChatCompletions => "chat/completions",
            EndpointKind::Messages => "messages",
            EndpointKind::Responses => "responses",
        };
        url.set_path(&format!("{base_path}/{suffix}"));
        url
    }
}

async fn rejected_response(response: reqwest::Response) -> OpenCodeError {
    let status = response.status();
    let retry_after = response
        .headers()
        .get(http::header::RETRY_AFTER)
        .and_then(|value| value.to_str().ok())
        .map(str::to_string);
    let mut stream = response.bytes_stream();
    let mut body = Vec::new();
    while body.len() < 64 * 1024 {
        let Some(chunk) = stream.next().await else {
            break;
        };
        let Ok(chunk) = chunk else {
            break;
        };
        let remaining = 64 * 1024 - body.len();
        body.extend_from_slice(&chunk[..chunk.len().min(remaining)]);
    }
    let message = serde_json::from_slice::<serde_json::Value>(&body)
        .ok()
        .and_then(|value| {
            value
                .pointer("/error/message")
                .or_else(|| value.get("message"))
                .and_then(|value| value.as_str())
                .map(str::to_string)
        })
        .filter(|value| !value.is_empty())
        .unwrap_or_else(|| format!("OpenCode Go upstream returned HTTP {status}"));
    OpenCodeError {
        status,
        retry_after,
        message,
    }
}

fn safe_headers(headers: &reqwest::header::HeaderMap) -> serde_json::Value {
    let mut result = serde_json::Map::new();
    for name in [
        "content-type",
        "content-length",
        "retry-after",
        "x-request-id",
    ] {
        if let Some(value) = headers.get(name).and_then(|value| value.to_str().ok()) {
            result.insert(
                name.to_string(),
                serde_json::Value::String(value.to_string()),
            );
        }
    }
    serde_json::Value::Object(result)
}

#[cfg(test)]
mod tests {
    use super::*;
    use axum::{
        Json, Router,
        extract::{OriginalUri, State},
        http::HeaderMap,
        routing::post,
    };
    use std::sync::Mutex;

    #[derive(Debug)]
    struct SeenRequest {
        path: String,
        authorization: String,
        x_api_key: String,
        anthropic_version: String,
        x_opencode_session: String,
        body: serde_json::Value,
    }

    type Seen = Arc<Mutex<Vec<SeenRequest>>>;

    async fn capture_request(
        State(seen): State<Seen>,
        OriginalUri(uri): OriginalUri,
        headers: HeaderMap,
        Json(body): Json<serde_json::Value>,
    ) -> Json<serde_json::Value> {
        seen.lock().unwrap().push(SeenRequest {
            path: uri.path().to_string(),
            authorization: headers
                .get(http::header::AUTHORIZATION)
                .and_then(|value| value.to_str().ok())
                .unwrap_or_default()
                .to_string(),
            x_api_key: headers
                .get("x-api-key")
                .and_then(|value| value.to_str().ok())
                .unwrap_or_default()
                .to_string(),
            anthropic_version: headers
                .get("anthropic-version")
                .and_then(|value| value.to_str().ok())
                .unwrap_or_default()
                .to_string(),
            x_opencode_session: headers
                .get("x-opencode-session")
                .and_then(|value| value.to_str().ok())
                .unwrap_or_default()
                .to_string(),
            body,
        });
        Json(serde_json::json!({"ok": true}))
    }

    #[test]
    fn endpoint_urls_preserve_go_base_path() {
        let client = OpenCodeClient::new(
            "https://opencode.ai/zen/go/v1/".to_string(),
            Some("test".to_string()),
        )
        .unwrap();
        assert_eq!(
            client.endpoint_url(EndpointKind::ChatCompletions).as_str(),
            "https://opencode.ai/zen/go/v1/chat/completions"
        );
        assert_eq!(
            client.endpoint_url(EndpointKind::Messages).as_str(),
            "https://opencode.ai/zen/go/v1/messages"
        );
        assert_eq!(
            client.endpoint_url(EndpointKind::Responses).as_str(),
            "https://opencode.ai/zen/go/v1/responses"
        );
    }

    #[tokio::test]
    async fn endpoints_use_protocol_native_auth_and_wire_model_ids() {
        let seen: Seen = Arc::new(Mutex::new(Vec::new()));
        let app = Router::new()
            .route("/v1/chat/completions", post(capture_request))
            .route("/v1/messages", post(capture_request))
            .route("/v1/responses", post(capture_request))
            .with_state(seen.clone());
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });

        let client =
            OpenCodeClient::new(format!("http://{address}/v1"), Some("test-key".to_string()))
                .unwrap();
        for (endpoint, model, session_id) in [
            (EndpointKind::ChatCompletions, "glm-5.2", Some("sess-abc")),
            (EndpointKind::Messages, "minimax-m3", None),
            (EndpointKind::Responses, "gpt-5.6-luna", Some("sess-xyz")),
        ] {
            client
                .post(
                    endpoint,
                    &serde_json::json!({"model": model, "messages": []}),
                    false,
                    None,
                    session_id,
                )
                .await
                .unwrap()
                .into_bytes()
                .await
                .unwrap();
        }
        server.abort();

        let seen = seen.lock().unwrap();
        assert_eq!(seen.len(), 3);
        assert_eq!(seen[0].path, "/v1/chat/completions");
        assert_eq!(seen[1].path, "/v1/messages");
        assert_eq!(seen[2].path, "/v1/responses");
        assert_eq!(seen[0].authorization, "Bearer test-key");
        assert!(seen[0].x_api_key.is_empty());
        assert!(seen[1].authorization.is_empty());
        assert_eq!(seen[1].x_api_key, "test-key");
        assert_eq!(seen[2].authorization, "Bearer test-key");
        assert!(seen[2].x_api_key.is_empty());
        assert!(seen[0].anthropic_version.is_empty());
        assert_eq!(seen[1].anthropic_version, "2023-06-01");
        assert!(seen[2].anthropic_version.is_empty());
        assert_eq!(seen[0].body["model"], "glm-5.2");
        assert_eq!(seen[1].body["model"], "minimax-m3");
        assert_eq!(seen[2].body["model"], "gpt-5.6-luna");
        assert_eq!(seen[0].x_opencode_session, "sess-abc");
        assert!(!seen[1].x_opencode_session.is_empty());
        assert_ne!(seen[1].x_opencode_session, "sess-abc");
        assert_eq!(seen[2].x_opencode_session, "sess-xyz");
    }
}