Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
pub mod chat;
pub mod client;
pub mod messages;
pub mod model;
pub mod responses;
use std::sync::Arc;
use async_trait::async_trait;
use axum::{
Json,
body::Body,
http::StatusCode,
response::{IntoResponse, Response},
};
use crate::anthropic::{
error::json_error,
schema::{CountTokensResponse, MessagesRequest},
};
use crate::provider::{
CliHandlers, Generation, GenerationBody, Provider, ProviderError, ProviderErrorKind,
RequestContext,
};
use crate::providers::kimi::count_tokens;
use self::client::{OpenCodeClient, OpenCodeError};
use self::model::EndpointKind;
enum ClientState {
Ready(Arc<OpenCodeClient>),
Invalid(String),
}
pub struct OpenCodeProvider {
client: ClientState,
}
impl OpenCodeProvider {
pub fn new() -> Self {
let client = OpenCodeClient::new(
crate::config::opencode_base_url(),
crate::config::opencode_api_key(),
)
.map(Arc::new)
.map(ClientState::Ready)
.unwrap_or_else(|error| ClientState::Invalid(error.to_string()));
Self { client }
}
#[cfg(test)]
fn with_client(client: OpenCodeClient) -> Self {
Self {
client: ClientState::Ready(Arc::new(client)),
}
}
fn client(&self) -> Result<Arc<OpenCodeClient>, String> {
match &self.client {
ClientState::Ready(client) => Ok(client.clone()),
ClientState::Invalid(error) => Err(error.clone()),
}
}
async fn buffered_messages_response(
&self,
body: MessagesRequest,
ctx: RequestContext,
) -> Response {
let requested = body.model.as_deref().unwrap_or_default();
let Some(spec) = model::resolve(requested) else {
return unsupported_model(requested);
};
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.model_resolved(&ctx.req_id, spec.id);
}
let client = match self.client() {
Ok(client) => client,
Err(error) => return invalid_configuration_response(error),
};
let message_id = format!("msg_{}", uuid::Uuid::new_v4().simple());
let value = match spec.endpoint {
EndpointKind::ChatCompletions => {
let translated = match chat::prepare_request(&body, spec.id) {
Ok(translated) => translated,
Err(error) => return invalid_request_response(error),
};
mark_upstream_started(&ctx);
let upstream = match client
.post(
spec.endpoint,
&translated,
true,
ctx.traffic.clone(),
ctx.session_id.as_deref(),
)
.await
{
Ok(upstream) => upstream,
Err(error) => return map_error(error),
};
let bytes = match upstream.into_bytes().await {
Ok(bytes) => bytes,
Err(error) => return map_error(error),
};
capture_buffered_upstream(&ctx, &bytes, "sse");
match chat::accumulate_response(&bytes, &message_id, requested) {
Ok(value) => value,
Err(error) => return invalid_upstream_response(error),
}
}
EndpointKind::Messages => {
let translated = match messages::prepare_request(&body, spec.id) {
Ok(translated) => translated,
Err(error) => return invalid_request_response(error),
};
mark_upstream_started(&ctx);
let upstream = match client
.post(
spec.endpoint,
&translated,
false,
ctx.traffic.clone(),
ctx.session_id.as_deref(),
)
.await
{
Ok(upstream) => upstream,
Err(error) => return map_error(error),
};
let bytes = match upstream.into_bytes().await {
Ok(bytes) => bytes,
Err(error) => return map_error(error),
};
capture_buffered_upstream(&ctx, &bytes, "json");
match serde_json::from_slice::<serde_json::Value>(&bytes) {
Ok(value) => value,
Err(error) => return invalid_upstream_response(error),
}
}
EndpointKind::Responses => {
let translated =
match responses::prepare_request(&body, spec.id, ctx.session_id.clone()) {
Ok(translated) => translated,
Err(error) => return invalid_request_response(error),
};
mark_upstream_started(&ctx);
let upstream = match client
.post(
spec.endpoint,
&translated,
true,
ctx.traffic.clone(),
ctx.session_id.as_deref(),
)
.await
{
Ok(upstream) => upstream,
Err(error) => return map_error(error),
};
let bytes = match upstream.into_bytes().await {
Ok(bytes) => bytes,
Err(error) => return map_error(error),
};
capture_buffered_upstream(&ctx, &bytes, "sse");
match responses::accumulate_response(&bytes, &message_id, requested) {
Ok(value) => value,
Err(error) => return invalid_upstream_response(error),
}
}
};
if let Some(traffic) = ctx.traffic.as_ref() {
traffic.write_json("051-downstream-response", &value);
}
update_buffered_usage(&ctx, &value);
(StatusCode::OK, Json(value)).into_response()
}
}
impl Default for OpenCodeProvider {
fn default() -> Self {
Self::new()
}
}
pub fn advertised_models() -> Vec<String> {
model::advertised_models()
}
#[async_trait]
impl Provider for OpenCodeProvider {
fn name(&self) -> &'static str {
"opencode"
}
fn supported_models(&self) -> Vec<String> {
advertised_models()
}
fn cli(&self) -> &'static dyn CliHandlers {
&OPENCODE_CLI
}
async fn handle_messages(&self, body: MessagesRequest, ctx: RequestContext) -> Response {
if !body.stream {
return self.buffered_messages_response(body, ctx).await;
}
match self.generate_anthropic_stream(body, ctx).await {
Ok(generation) => sse_response(generation.body),
Err(error) => map_provider_error(error),
}
}
async fn handle_count_tokens(&self, body: MessagesRequest, ctx: RequestContext) -> Response {
let requested = body.model.as_deref().unwrap_or_default();
let Some(spec) = model::resolve(requested) else {
return unsupported_model(requested);
};
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.model_resolved(&ctx.req_id, spec.id);
}
let tokens = count_tokens::count_tokens(&body);
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.usage_updated(&ctx.req_id, Some(tokens), None);
}
(
StatusCode::OK,
Json(CountTokensResponse {
input_tokens: tokens,
}),
)
.into_response()
}
async fn generate_anthropic_stream(
&self,
mut body: MessagesRequest,
ctx: RequestContext,
) -> Result<Generation, ProviderError> {
body.stream = true;
let requested = body.model.as_deref().unwrap_or_default();
let spec = model::resolve(requested).ok_or_else(|| {
ProviderError::new(
StatusCode::BAD_REQUEST,
ProviderErrorKind::InvalidRequest,
format!("Unsupported OpenCode Go model: {requested}"),
)
})?;
let client = self.client().map_err(|error| {
ProviderError::new(
StatusCode::INTERNAL_SERVER_ERROR,
ProviderErrorKind::Api,
format!("Invalid OpenCode Go configuration: {error}"),
)
})?;
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.model_resolved(&ctx.req_id, spec.id);
monitor.upstream_started(&ctx.req_id);
}
let message_id = format!("msg_{}", uuid::Uuid::new_v4().simple());
let body = match spec.endpoint {
EndpointKind::ChatCompletions => {
let translated = chat::prepare_request(&body, spec.id)
.map_err(invalid_request_provider_error)?;
let upstream = client
.post(
spec.endpoint,
&translated,
true,
ctx.traffic.clone(),
ctx.session_id.as_deref(),
)
.await
.map_err(opencode_provider_error)?;
chat::stream_body(
upstream,
message_id,
requested.to_string(),
ctx.monitor.clone(),
ctx.req_id.clone(),
ctx.traffic.clone(),
)
}
EndpointKind::Messages => {
let translated = messages::prepare_request(&body, spec.id)
.map_err(invalid_request_provider_error)?;
let upstream = client
.post(
spec.endpoint,
&translated,
true,
ctx.traffic.clone(),
ctx.session_id.as_deref(),
)
.await
.map_err(opencode_provider_error)?;
messages::stream_body(
upstream,
ctx.monitor.clone(),
ctx.req_id.clone(),
ctx.traffic.clone(),
)
}
EndpointKind::Responses => {
let translated = responses::prepare_request(&body, spec.id, ctx.session_id.clone())
.map_err(invalid_request_provider_error)?;
let upstream = client
.post(
spec.endpoint,
&translated,
true,
ctx.traffic.clone(),
ctx.session_id.as_deref(),
)
.await
.map_err(opencode_provider_error)?;
responses::stream_body(
upstream,
message_id,
requested.to_string(),
ctx.monitor.clone(),
ctx.req_id.clone(),
ctx.traffic.clone(),
)
}
};
Ok(Generation {
body: GenerationBody::LiveSse(body),
resolved_model: spec.id.to_string(),
})
}
}
fn invalid_request_provider_error(error: impl std::fmt::Display) -> ProviderError {
ProviderError::new(
StatusCode::BAD_REQUEST,
ProviderErrorKind::InvalidRequest,
error.to_string(),
)
}
fn opencode_provider_error(error: OpenCodeError) -> ProviderError {
let (status, kind) = match error.status {
StatusCode::UNAUTHORIZED => (StatusCode::UNAUTHORIZED, ProviderErrorKind::Authentication),
StatusCode::PAYMENT_REQUIRED | StatusCode::FORBIDDEN => {
(error.status, ProviderErrorKind::Permission)
}
StatusCode::TOO_MANY_REQUESTS => {
(StatusCode::TOO_MANY_REQUESTS, ProviderErrorKind::RateLimit)
}
status if status.is_client_error() => (status, ProviderErrorKind::InvalidRequest),
_ => (StatusCode::BAD_GATEWAY, ProviderErrorKind::Api),
};
let mut mapped = ProviderError::new(status, kind, error.message);
mapped.retry_after = error.retry_after;
mapped
}
fn map_error(error: OpenCodeError) -> Response {
map_provider_error(opencode_provider_error(error))
}
fn map_provider_error(error: ProviderError) -> Response {
let response = json_error(error.status, error.error_type(), error.message);
if let Some(retry_after) = error.retry_after {
([(http::header::RETRY_AFTER, retry_after)], response).into_response()
} else {
response
}
}
fn unsupported_model(requested: &str) -> Response {
json_error(
StatusCode::BAD_REQUEST,
"invalid_request_error",
format!("Unsupported OpenCode Go model: {requested}"),
)
}
fn invalid_configuration_response(error: impl std::fmt::Display) -> Response {
json_error(
StatusCode::INTERNAL_SERVER_ERROR,
"api_error",
format!("Invalid OpenCode Go configuration: {error}"),
)
}
fn invalid_request_response(error: impl std::fmt::Display) -> Response {
json_error(
StatusCode::BAD_REQUEST,
"invalid_request_error",
error.to_string(),
)
}
fn invalid_upstream_response(error: impl std::fmt::Display) -> Response {
json_error(
StatusCode::BAD_GATEWAY,
"api_error",
format!("OpenCode Go response translation failed: {error}"),
)
}
fn mark_upstream_started(ctx: &RequestContext) {
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.upstream_started(&ctx.req_id);
}
}
fn capture_buffered_upstream(ctx: &RequestContext, bytes: &[u8], extension: &str) {
if let Some(traffic) = ctx.traffic.as_ref() {
traffic.write_bytes(&format!("032-upstream-response-body.{extension}"), bytes);
}
}
fn update_buffered_usage(ctx: &RequestContext, value: &serde_json::Value) {
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.usage_updated(
&ctx.req_id,
value
.pointer("/usage/input_tokens")
.and_then(serde_json::Value::as_u64),
value
.pointer("/usage/output_tokens")
.and_then(serde_json::Value::as_u64),
);
}
}
fn sse_response(body: GenerationBody) -> Response {
let body = match body {
GenerationBody::BufferedSse(bytes) => Body::from(bytes),
GenerationBody::LiveSse(body) => body,
};
(
[
(http::header::CONTENT_TYPE, "text/event-stream"),
(http::header::CACHE_CONTROL, "no-cache"),
(http::header::CONNECTION, "keep-alive"),
],
body,
)
.into_response()
}
struct OpenCodeCli;
impl CliHandlers for OpenCodeCli {
fn login(&self) -> anyhow::Result<()> {
anyhow::bail!(
"OpenCode Go uses an API key; set CCP_OPENCODE_API_KEY, OPENCODE_API_KEY, or opencode.apiKey in config.json"
)
}
fn device(&self) -> anyhow::Result<()> {
self.login()
}
fn status(&self) -> anyhow::Result<()> {
let Some(source) = crate::config::opencode_api_key_source() else {
anyhow::bail!("Not authenticated");
};
println!("API key configured: true");
println!("Source: {source}");
println!("Base URL: {}", crate::config::opencode_base_url());
Ok(())
}
fn logout(&self) -> anyhow::Result<()> {
anyhow::bail!(
"OpenCode Go credentials are managed through environment variables or config.json"
)
}
}
static OPENCODE_CLI: OpenCodeCli = OpenCodeCli;
#[cfg(test)]
mod tests {
use axum::{
Json, Router,
body::Body,
extract::{OriginalUri, State},
http::HeaderMap,
response::{IntoResponse, Response},
routing::post,
};
use bytes::Bytes;
use futures_util::StreamExt;
use serde_json::json;
use std::convert::Infallible;
use std::sync::Mutex;
use super::*;
fn context() -> RequestContext {
RequestContext {
req_id: "req_test".to_string(),
provider: "opencode".to_string(),
session_id: None,
session_seq: None,
monitor: None,
traffic: None,
}
}
fn context_with_session(session_id: &str) -> RequestContext {
RequestContext {
session_id: Some(session_id.to_string()),
..context()
}
}
#[tokio::test]
async fn claude_code_session_id_is_forwarded_as_opencode_session_header() {
let seen: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
async fn capture_session_header(
State(seen): State<Arc<Mutex<Vec<String>>>>,
headers: HeaderMap,
Json(_body): Json<serde_json::Value>,
) -> Response {
seen.lock().unwrap().push(
headers
.get("x-opencode-session")
.and_then(|value| value.to_str().ok())
.unwrap_or_default()
.to_string(),
);
Json(json!({
"id": "msg_native",
"type": "message",
"role": "assistant",
"model": "minimax-m3",
"content": [{"type":"text","text":"hello"}],
"stop_reason": "end_turn",
"usage": {"input_tokens":1,"output_tokens":1}
}))
.into_response()
}
let app = Router::new()
.route("/v1/messages", post(capture_session_header))
.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 provider = OpenCodeProvider::with_client(
OpenCodeClient::new(format!("http://{address}/v1"), Some("test-key".to_string()))
.unwrap(),
);
let body: MessagesRequest = serde_json::from_value(json!({
"model": "opencode-go/minimax-m3",
"stream": false,
"messages": [{"role":"user","content":"hello"}]
}))
.unwrap();
let response = provider
.handle_messages(body, context_with_session("claude-session-42"))
.await;
assert_eq!(response.status(), StatusCode::OK);
server.abort();
let seen = seen.lock().unwrap();
assert_eq!(seen.as_slice(), ["claude-session-42"]);
}
#[tokio::test]
async fn missing_key_is_actionable() {
let client = OpenCodeClient::new("https://example.com/v1".into(), None).unwrap();
let provider = OpenCodeProvider::with_client(client);
let body: MessagesRequest = serde_json::from_value(json!({
"model": "glm-5.2",
"messages": [{"role": "user", "content": "hello"}]
}))
.unwrap();
let response = provider.handle_messages(body, context()).await;
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert!(
value["error"]["message"]
.as_str()
.unwrap()
.contains("OPENCODE_API_KEY")
);
}
#[tokio::test]
async fn count_tokens_is_local_for_all_protocol_families() {
let provider = OpenCodeProvider::with_client(
OpenCodeClient::new("https://example.com/v1".into(), None).unwrap(),
);
for model in ["glm-5.2", "minimax-m3", "opencode-go/gpt-5.6-luna"] {
let body: MessagesRequest = serde_json::from_value(json!({
"model": model,
"messages": [{"role": "user", "content": "hello world"}]
}))
.unwrap();
let response = provider.handle_count_tokens(body, context()).await;
assert_eq!(response.status(), StatusCode::OK);
}
}
async fn mock_go_upstream(
OriginalUri(uri): OriginalUri,
headers: HeaderMap,
Json(body): Json<serde_json::Value>,
) -> Response {
if uri.path().ends_with("/messages") {
assert_eq!(
headers
.get("x-api-key")
.and_then(|value| value.to_str().ok()),
Some("test-key")
);
} else {
assert_eq!(
headers
.get(http::header::AUTHORIZATION)
.and_then(|value| value.to_str().ok()),
Some("Bearer test-key")
);
}
if body["model"] == "qwen3.7-max" {
return (
StatusCode::TOO_MANY_REQUESTS,
[(http::header::RETRY_AFTER, "17")],
Json(json!({"error":{"message":"Go limit reached"}})),
)
.into_response();
}
if uri.path().ends_with("/chat/completions") {
return (
[(http::header::CONTENT_TYPE, "text/event-stream")],
concat!(
"data: {\"choices\":[{\"delta\":{\"content\":\"hello from chat\"}}]}\n\n",
"data: {\"choices\":[{\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":5,\"completion_tokens\":3}}\n\n",
"data: [DONE]\n\n"
),
)
.into_response();
}
if uri.path().ends_with("/responses") {
if body["max_output_tokens"] == 8 {
return (
[(http::header::CONTENT_TYPE, "text/event-stream")],
concat!(
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_limited\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"truncated response\"}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.incomplete\",\"response\":{\"id\":\"resp_limited\",\"status\":\"incomplete\",\"error\":null,\"incomplete_details\":{\"reason\":\"max_output_tokens\"},\"usage\":{\"input_tokens\":6,\"output_tokens\":8}}}\n\n",
"data: [DONE]\n\n"
),
)
.into_response();
}
if body["max_output_tokens"] == 9 {
return (
[(http::header::CONTENT_TYPE, "text/event-stream")],
concat!(
"data: {\"type\":\"response.incomplete\",\"response\":{\"id\":\"resp_filtered\",\"status\":\"incomplete\",\"error\":null,\"incomplete_details\":{\"reason\":\"content_filter\"},\"usage\":{\"input_tokens\":6,\"output_tokens\":0}}}\n\n",
"data: [DONE]\n\n"
),
)
.into_response();
}
return (
[(http::header::CONTENT_TYPE, "text/event-stream")],
concat!(
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"hello from responses\"}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"status\":\"completed\",\"usage\":{\"input_tokens\":6,\"output_tokens\":3}}}\n\n"
),
)
.into_response();
}
if body["stream"] == true {
return (
[(http::header::CONTENT_TYPE, "text/event-stream")],
concat!(
"event: message_start\n",
"data: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_native\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"minimax-m3\",\"content\":[],\"stop_reason\":null,\"usage\":{\"input_tokens\":4,\"output_tokens\":0}}}\n\n",
"event: message_stop\n",
"data: {\"type\":\"message_stop\"}\n\n"
),
)
.into_response();
}
Json(json!({
"id": "msg_native",
"type": "message",
"role": "assistant",
"model": body["model"],
"content": [{"type":"text","text":"hello from messages"}],
"stop_reason": "end_turn",
"usage": {"input_tokens":4,"output_tokens":3}
}))
.into_response()
}
async fn mock_provider() -> (OpenCodeProvider, tokio::task::JoinHandle<()>) {
let app = Router::new()
.route("/v1/chat/completions", post(mock_go_upstream))
.route("/v1/messages", post(mock_go_upstream))
.route("/v1/responses", post(mock_go_upstream));
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();
(OpenCodeProvider::with_client(client), server)
}
async fn delayed_chat_upstream() -> Response {
let stream = futures_util::stream::unfold(0u8, |step| async move {
match step {
0 => Some((
Ok::<Bytes, Infallible>(Bytes::from_static(
b"data: {\"choices\":[{\"delta\":{\"content\":\"early\"}}]}\n\n",
)),
1,
)),
1 => {
tokio::time::sleep(std::time::Duration::from_secs(30)).await;
Some((
Ok(Bytes::from_static(
b"data: {\"choices\":[{\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":2,\"completion_tokens\":1}}\n\ndata: [DONE]\n\n",
)),
2,
))
}
_ => None,
}
});
(
[(http::header::CONTENT_TYPE, "text/event-stream")],
Body::from_stream(stream),
)
.into_response()
}
#[tokio::test]
async fn generate_contract_streams_before_upstream_completion() {
let app = Router::new().route("/v1/chat/completions", post(delayed_chat_upstream));
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 provider = OpenCodeProvider::with_client(
OpenCodeClient::new(format!("http://{address}/v1"), Some("test-key".to_string()))
.unwrap(),
);
let body: MessagesRequest = serde_json::from_value(json!({
"model": "glm-5.2",
"messages": [{"role": "user", "content": "hello"}]
}))
.unwrap();
let generation = provider
.generate_anthropic_stream(body, context())
.await
.unwrap();
let GenerationBody::LiveSse(body) = generation.body else {
panic!("OpenCode Go generation must remain live");
};
let mut stream = body.into_data_stream();
let first = tokio::time::timeout(std::time::Duration::from_secs(1), stream.next())
.await
.expect("the proxy buffered the stream until upstream completion")
.expect("stream ended before the first translated event")
.unwrap();
assert!(String::from_utf8_lossy(&first).contains("early"));
server.abort();
}
#[tokio::test]
async fn buffered_messages_cover_all_three_upstream_protocols() {
let (provider, server) = mock_provider().await;
for (model, expected) in [
("glm-5.2", "hello from chat"),
("opencode-go/minimax-m3", "hello from messages"),
("opencode-go/gpt-5.6-luna", "hello from responses"),
] {
let body: MessagesRequest = serde_json::from_value(json!({
"model": model,
"stream": false,
"messages": [{"role":"user","content":"hello"}]
}))
.unwrap();
let response = provider.handle_messages(body, context()).await;
assert_eq!(response.status(), StatusCode::OK, "model {model}");
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(value["content"][0]["text"], expected, "model {model}");
}
server.abort();
}
#[tokio::test]
async fn responses_max_output_tokens_is_a_normal_buffered_completion() {
let (provider, server) = mock_provider().await;
let body: MessagesRequest = serde_json::from_value(json!({
"model": "opencode-go/gpt-5.6-luna",
"stream": false,
"max_tokens": 8,
"messages": [{"role":"user","content":"write a long response"}]
}))
.unwrap();
let response = provider.handle_messages(body, context()).await;
assert_eq!(response.status(), StatusCode::OK);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(value["content"][0]["text"], "truncated response");
assert_eq!(value["stop_reason"], "max_tokens");
assert_eq!(value["usage"]["output_tokens"], 8);
server.abort();
}
#[tokio::test]
async fn responses_max_output_tokens_is_a_normal_streaming_completion() {
let (provider, server) = mock_provider().await;
let body: MessagesRequest = serde_json::from_value(json!({
"model": "opencode-go/gpt-5.6-luna",
"max_tokens": 8,
"messages": [{"role":"user","content":"write a long response"}]
}))
.unwrap();
let generation = provider
.generate_anthropic_stream(body, context())
.await
.unwrap();
let GenerationBody::LiveSse(body) = generation.body else {
panic!("OpenCode Go generation must remain live");
};
let bytes = axum::body::to_bytes(body, usize::MAX).await.unwrap();
let output = String::from_utf8(bytes.to_vec()).unwrap();
assert!(output.contains("truncated response"));
assert!(output.contains(r#""stop_reason":"max_tokens""#));
assert!(output.contains("event: message_stop"));
assert!(!output.contains("event: error"));
server.abort();
}
#[tokio::test]
async fn responses_content_filter_is_not_misreported_as_max_tokens() {
let (provider, server) = mock_provider().await;
let body: MessagesRequest = serde_json::from_value(json!({
"model": "opencode-go/gpt-5.6-luna",
"stream": false,
"max_tokens": 9,
"messages": [{"role":"user","content":"hello"}]
}))
.unwrap();
let response = provider.handle_messages(body, context()).await;
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(value["error"]["type"], "api_error");
assert!(
value["error"]["message"]
.as_str()
.unwrap()
.contains("content_filter")
);
server.abort();
}
#[tokio::test]
async fn streaming_contract_covers_all_three_upstream_protocols() {
let (provider, server) = mock_provider().await;
for model in [
"glm-5.2",
"opencode-go/minimax-m3",
"opencode-go/gpt-5.6-luna",
] {
let body: MessagesRequest = serde_json::from_value(json!({
"model": model,
"messages": [{"role":"user","content":"hello"}]
}))
.unwrap();
let generation = provider
.generate_anthropic_stream(body, context())
.await
.unwrap();
assert_eq!(generation.resolved_model, model::resolve(model).unwrap().id);
let GenerationBody::LiveSse(body) = generation.body else {
panic!("OpenCode Go generation must remain live");
};
let bytes = axum::body::to_bytes(body, usize::MAX).await.unwrap();
assert!(
String::from_utf8_lossy(&bytes).contains("message_stop"),
"model {model}"
);
}
server.abort();
}
#[tokio::test]
async fn rate_limit_and_retry_after_are_preserved() {
let (provider, server) = mock_provider().await;
let body: MessagesRequest = serde_json::from_value(json!({
"model": "qwen3.7-max",
"messages": [{"role":"user","content":"hello"}]
}))
.unwrap();
let response = provider.handle_messages(body, context()).await;
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
assert_eq!(
response
.headers()
.get(http::header::RETRY_AFTER)
.and_then(|value| value.to_str().ok()),
Some("17")
);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(value["error"]["type"], "rate_limit_error");
assert_eq!(value["error"]["message"], "Go limit reached");
server.abort();
}
#[test]
fn permission_errors_are_not_reported_as_authentication_failures() {
for status in [StatusCode::PAYMENT_REQUIRED, StatusCode::FORBIDDEN] {
let error = opencode_provider_error(OpenCodeError {
status,
retry_after: None,
message: "denied".into(),
});
assert_eq!(error.status, status);
assert_eq!(error.kind, ProviderErrorKind::Permission);
}
}
}