Skip to content

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

Rust

deduplicate provider translation helpers

Raine Virta129b4b9ff27f
diff --git a/src/providers/codex/auth/browser_login.rs b/src/providers/codex/auth/browser_login.rs
index 5cf7fe0..97303dc 100644
--- a/src/providers/codex/auth/browser_login.rs
+++ b/src/providers/codex/auth/browser_login.rs
@@ -199,136 +199,35 @@ fn handle_callback(
#[cfg(test)]
mod tests {
use super::*;
+ use crate::providers::codex::auth::test_http;
use std::sync::Arc;
- use std::sync::atomic::{AtomicBool, Ordering};
/// A minimal TCP-based mock auth server for browser login tests.
struct MockBrowserLoginAuthServer {
- url: String,
- #[allow(dead_code)]
- shutdown: Arc<AtomicBool>,
+ server: test_http::MockServer,
}
impl MockBrowserLoginAuthServer {
fn new() -> Self {
- let shutdown = Arc::new(AtomicBool::new(false));
- let sd = shutdown.clone();
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- let url = format!("http://{addr}");
- listener.set_nonblocking(true).expect("nonblocking");
- let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-
- std::thread::spawn(move || {
- let _ = ready_tx.send(());
- loop {
- if sd.load(Ordering::Relaxed) {
- return;
+ let server = test_http::spawn_mock_server(
+ "mock browser login auth server should become ready",
+ |request| {
+ if request.contains("/oauth/token") {
+ let body = r#"{"access_token":"bt_at","refresh_token":"bt_rt","expires_in":3600,"id_token":"bt_id"}"#;
+ test_http::json_response(200, body)
+ } else {
+ test_http::json_response(404, r#"{"error":"not found"}"#)
}
- match listener.accept() {
- Ok((mut stream, _)) => {
- let Some(request) = read_http_request(&mut stream) else {
- continue;
- };
-
- let response = if request.contains("/oauth/token") {
- // Token exchange - return success
- let body = r#"{"access_token":"bt_at","refresh_token":"bt_rt","expires_in":3600,"id_token":"bt_id"}"#;
- format!(
- "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",
- body.len()
- )
- } else {
- // Authorize endpoint or any other - return 404
- let body = r#"{"error":"not found"}"#;
- format!(
- "HTTP/1.1 404 Not Found\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",
- body.len()
- )
- };
-
- let _ = stream.write_all(response.as_bytes());
- let _ = stream.flush();
- }
- Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
- std::thread::sleep(Duration::from_millis(10));
- }
- Err(_) => break,
- }
- }
- });
- ready_rx
- .recv_timeout(Duration::from_secs(1))
- .expect("mock browser login auth server should become ready");
-
- Self { url, shutdown }
- }
- }
-
- impl Drop for MockBrowserLoginAuthServer {
- fn drop(&mut self) {
- self.shutdown.store(true, Ordering::Relaxed);
- }
- }
-
- /// Simulate a browser callback request by connecting to our browser login
- /// server and sending a crafted HTTP GET request.
- fn send_callback_request(addr: std::net::SocketAddr, path: &str) -> String {
- let mut stream = std::net::TcpStream::connect(addr).unwrap();
- let request =
- format!("GET {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n");
- let _ = stream.write_all(request.as_bytes());
- let _ = stream.flush();
-
- let mut buf = vec![0u8; 4096];
- let n = stream.read(&mut buf).unwrap_or(0);
- String::from_utf8_lossy(&buf[..n]).to_string()
- }
-
- fn read_http_request(stream: &mut std::net::TcpStream) -> Option<String> {
- let _ = stream.set_nonblocking(false);
- let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
- let mut request = Vec::new();
- let mut chunk = [0; 4096];
-
- loop {
- let n = stream.read(&mut chunk).ok()?;
- if n == 0 {
- break;
- }
- request.extend_from_slice(&chunk[..n]);
-
- if let Some(header_end) = find_header_end(&request) {
- let content_length = content_length(&request[..header_end]).unwrap_or(0);
- if request.len() >= header_end + 4 + content_length {
- break;
- }
- }
+ },
+ );
+ Self { server }
}
- if request.is_empty() {
- None
- } else {
- Some(String::from_utf8_lossy(&request).to_string())
+ fn url(&self) -> &str {
+ &self.server.url
}
}
- fn find_header_end(bytes: &[u8]) -> Option<usize> {
- bytes.windows(4).position(|window| window == b"\r\n\r\n")
- }
-
- fn content_length(headers: &[u8]) -> Option<usize> {
- let text = String::from_utf8_lossy(headers);
- text.lines().find_map(|line| {
- let (name, value) = line.split_once(':')?;
- if name.eq_ignore_ascii_case("content-length") {
- value.trim().parse().ok()
- } else {
- None
- }
- })
- }
-
#[test]
fn browser_login_rejects_wrong_path() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
@@ -355,7 +254,7 @@ mod tests {
});
let addr: std::net::SocketAddr = format!("127.0.0.1:{port}").parse().unwrap();
- let response = send_callback_request(addr, "/wrong/path");
+ let response = test_http::send_get(addr, "/wrong/path");
handle.join().unwrap();
assert!(response.contains("404"), "unexpected response: {response}");
assert!(
@@ -392,8 +291,7 @@ mod tests {
});
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
- let response =
- send_callback_request(addr, "/auth/callback?code=test_code&state=wrong_state");
+ let response = test_http::send_get(addr, "/auth/callback?code=test_code&state=wrong_state");
handle.join().unwrap();
assert!(response.contains("400"));
assert!(response.contains("Invalid callback"));
@@ -427,7 +325,7 @@ mod tests {
});
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
- let response = send_callback_request(addr, "/auth/callback?state=state");
+ let response = test_http::send_get(addr, "/auth/callback?state=state");
handle.join().unwrap();
assert!(response.contains("400"));
}
@@ -460,8 +358,7 @@ mod tests {
});
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
- let response =
- send_callback_request(addr, "/auth/callback?error=access_denied&state=state");
+ let response = test_http::send_get(addr, "/auth/callback?error=access_denied&state=state");
handle.join().unwrap();
assert!(response.contains("400"));
assert!(response.contains("access_denied"));
@@ -470,7 +367,7 @@ mod tests {
#[test]
fn callback_success_exchanges_tokens() {
let auth_server = MockBrowserLoginAuthServer::new();
- let auth_url = auth_server.url.clone();
+ let auth_url = auth_server.url().to_string();
let callback_result = Arc::new(std::sync::Mutex::new(None));
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
@@ -504,7 +401,7 @@ mod tests {
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
let response =
- send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");
+ test_http::send_get(addr, "/auth/callback?code=test_code&state=expected_state");
handle.join().unwrap();
assert!(response.contains("200"), "unexpected response: {response}");
let tokens = callback_result
@@ -522,49 +419,18 @@ mod tests {
#[test]
fn callback_exchange_failure_returns_error() {
- // Server that returns a 500 on token exchange
- let shutdown = Arc::new(AtomicBool::new(false));
- let sd = shutdown.clone();
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- let fail_issuer = format!("http://{addr}");
- listener.set_nonblocking(true).expect("nonblocking");
- let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-
- std::thread::spawn(move || {
- let _ = ready_tx.send(());
- loop {
- if sd.load(Ordering::Relaxed) {
- return;
- }
- match listener.accept() {
- Ok((mut stream, _)) => {
- let Some(request) = read_http_request(&mut stream) else {
- continue;
- };
-
- let body = if request.contains("/oauth/token") {
- r#"{"error":"bad exchange"}"#
- } else {
- r#"{"error":"nf"}"#
- };
- let response = format!(
- "HTTP/1.1 500 Internal Server Error\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",
- body.len()
- );
- let _ = stream.write_all(response.as_bytes());
- let _ = stream.flush();
- }
- Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
- std::thread::sleep(Duration::from_millis(10));
- }
- Err(_) => break,
- }
- }
- });
- ready_rx
- .recv_timeout(Duration::from_secs(1))
- .expect("mock browser login failure server should become ready");
+ let fail_server = test_http::spawn_mock_server(
+ "mock browser login failure server should become ready",
+ |request| {
+ let body = if request.contains("/oauth/token") {
+ r#"{"error":"bad exchange"}"#
+ } else {
+ r#"{"error":"nf"}"#
+ };
+ test_http::json_response(500, body)
+ },
+ );
+ let fail_issuer = fail_server.url.clone();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
@@ -594,14 +460,14 @@ mod tests {
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
let response =
- send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");
+ test_http::send_get(addr, "/auth/callback?code=test_code&state=expected_state");
handle.join().unwrap();
assert!(response.contains("500"), "unexpected response: {response}");
assert!(
response.contains("Token exchange failed"),
"unexpected response: {response}"
);
- shutdown.store(true, Ordering::Relaxed);
+ drop(fail_server);
}
#[test]
diff --git a/src/providers/codex/auth/device.rs b/src/providers/codex/auth/device.rs
index 8de77a4..d779730 100644
--- a/src/providers/codex/auth/device.rs
+++ b/src/providers/codex/auth/device.rs
@@ -220,6 +220,7 @@ impl Default for DeviceAuthClient {
#[cfg(test)]
mod tests {
use super::*;
+ use crate::providers::codex::auth::test_http;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
@@ -246,9 +247,7 @@ mod tests {
/// A minimal HTTP test server for the device auth flow.
struct MockDeviceServer {
- url: String,
- #[allow(dead_code)]
- shutdown: Arc<AtomicBool>,
+ server: test_http::MockServer,
saw_init: Arc<AtomicBool>,
saw_token_exchange: Arc<AtomicBool>,
saw_poll: Arc<AtomicBool>,
@@ -262,137 +261,42 @@ mod tests {
InitThenTimeout,
}
- fn json_response(status: u16, body: &str) -> String {
- let reason = match status {
- 200 => "OK",
- 403 => "Forbidden",
- 404 => "Not Found",
- 500 => "Internal Server Error",
- _ => "Unknown",
- };
- format!(
- "HTTP/1.1 {status} {reason}\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",
- body.len(),
- )
- }
-
- fn read_http_request(stream: &mut std::net::TcpStream) -> Option<String> {
- use std::io::Read;
-
- let _ = stream.set_nonblocking(false);
- let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
- let mut request = Vec::new();
- let mut chunk = [0; 4096];
-
- loop {
- let n = stream.read(&mut chunk).ok()?;
- if n == 0 {
- break;
- }
- request.extend_from_slice(&chunk[..n]);
-
- if let Some(header_end) = find_header_end(&request) {
- let content_length = content_length(&request[..header_end]).unwrap_or(0);
- if request.len() >= header_end + 4 + content_length {
- break;
- }
- }
- }
-
- if request.is_empty() {
- None
- } else {
- Some(String::from_utf8_lossy(&request).to_string())
- }
- }
-
- fn find_header_end(bytes: &[u8]) -> Option<usize> {
- bytes.windows(4).position(|window| window == b"\r\n\r\n")
- }
-
- fn content_length(headers: &[u8]) -> Option<usize> {
- let text = String::from_utf8_lossy(headers);
- text.lines().find_map(|line| {
- let (name, value) = line.split_once(':')?;
- if name.eq_ignore_ascii_case("content-length") {
- value.trim().parse().ok()
- } else {
- None
- }
- })
- }
-
impl MockDeviceServer {
fn new(scenario: DeviceScenario) -> Self {
let saw_init = Arc::new(AtomicBool::new(false));
let saw_token_exchange = Arc::new(AtomicBool::new(false));
let saw_poll = Arc::new(AtomicBool::new(false));
- let shutdown = Arc::new(AtomicBool::new(false));
let si = saw_init.clone();
let ste = saw_token_exchange.clone();
let sp = saw_poll.clone();
- let sd = shutdown.clone();
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind test server");
- let addr = listener.local_addr().unwrap();
- let url = format!("http://{addr}");
- listener.set_nonblocking(true).expect("set nonblocking");
- let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-
- std::thread::spawn(move || {
- let _ = ready_tx.send(());
- loop {
- if sd.load(Ordering::Relaxed) {
- return;
+ let server = test_http::spawn_mock_server(
+ "mock device server should become ready",
+ move |request| match scenario {
+ DeviceScenario::SuccessAfterPending => {
+ Self::handle_success_after_pending(request, &si, &sp, &ste)
}
- match listener.accept() {
- Ok((mut stream, _)) => {
- use std::io::Write;
- let Some(request) = read_http_request(&mut stream) else {
- continue;
- };
-
- let response = match scenario {
- DeviceScenario::SuccessAfterPending => {
- Self::handle_success_after_pending(&request, &si, &sp, &ste)
- }
- DeviceScenario::InitFailure => {
- Self::handle_init_failure(&request, &si)
- }
- DeviceScenario::PollFailure => {
- Self::handle_poll_failure(&request, &si, &sp)
- }
- DeviceScenario::TokenExchangeFailure => {
- Self::handle_token_exchange_failure(&request, &si, &sp, &ste)
- }
- DeviceScenario::InitThenTimeout => {
- Self::handle_init_then_timeout(&request, &si)
- }
- };
-
- let _ = stream.write_all(response.as_bytes());
- let _ = stream.flush();
- }
- Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
- std::thread::sleep(Duration::from_millis(10));
- }
- Err(_) => break,
+ DeviceScenario::InitFailure => Self::handle_init_failure(request, &si),
+ DeviceScenario::PollFailure => Self::handle_poll_failure(request, &si, &sp),
+ DeviceScenario::TokenExchangeFailure => {
+ Self::handle_token_exchange_failure(request, &si, &sp, &ste)
}
- }
- });
- ready_rx
- .recv_timeout(Duration::from_secs(1))
- .expect("mock device server should become ready");
+ DeviceScenario::InitThenTimeout => Self::handle_init_then_timeout(request, &si),
+ },
+ );
Self {
- url,
- shutdown,
+ server,
saw_init,
saw_token_exchange,
saw_poll,
}
}
+ fn url(&self) -> &str {
+ &self.server.url
+ }
+
fn handle_success_after_pending(
request: &str,
saw_init: &AtomicBool,
@@ -401,33 +305,33 @@ mod tests {
) -> String {
if request.contains("/api/accounts/deviceauth/usercode") {
saw_init.store(true, Ordering::Relaxed);
- Self::json_response(
+ test_http::json_response(
200,
r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"2"}"#,
)
} else if request.contains("/api/accounts/deviceauth/token") {
saw_poll.store(true, Ordering::Relaxed);
- Self::json_response(
+ test_http::json_response(
200,
r#"{"authorization_code":"auth_code_1","code_verifier":"verifier_1"}"#,
)
} else if request.contains("/oauth/token") {
saw_exchange.store(true, Ordering::Relaxed);
- Self::json_response(
+ test_http::json_response(
200,
r#"{"access_token":"at_1","refresh_token":"rt_1","expires_in":3600,"id_token":"fake_id_token"}"#,
)
} else {
- Self::json_response(404, r#"{"error":"not found"}"#)
+ test_http::json_response(404, r#"{"error":"not found"}"#)
}
}
fn handle_init_failure(request: &str, saw_init: &AtomicBool) -> String {
if request.contains("/api/accounts/deviceauth/usercode") {
saw_init.store(true, Ordering::Relaxed);
- Self::json_response(500, r#"{"error":"server error"}"#)
+ test_http::json_response(500, r#"{"error":"server error"}"#)
} else {
- Self::json_response(404, r#"{"error":"not found"}"#)
+ test_http::json_response(404, r#"{"error":"not found"}"#)
}
}
@@ -438,15 +342,15 @@ mod tests {
) -> String {
if request.contains("/api/accounts/deviceauth/usercode") {
saw_init.store(true, Ordering::Relaxed);
- Self::json_response(
+ test_http::json_response(
200,
r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"2"}"#,
)
} else if request.contains("/api/accounts/deviceauth/token") {
saw_poll.store(true, Ordering::Relaxed);
- Self::json_response(500, r#"{"error":"poll error"}"#)
+ test_http::json_response(500, r#"{"error":"poll error"}"#)
} else {
- Self::json_response(404, r#"{"error":"not found"}"#)
+ test_http::json_response(404, r#"{"error":"not found"}"#)
}
}
@@ -458,63 +362,43 @@ mod tests {
) -> String {
if request.contains("/api/accounts/deviceauth/usercode") {
saw_init.store(true, Ordering::Relaxed);
- Self::json_response(
+ test_http::json_response(
200,
r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"2"}"#,
)
} else if request.contains("/api/accounts/deviceauth/token") {
saw_poll.store(true, Ordering::Relaxed);
- Self::json_response(
+ test_http::json_response(
200,
r#"{"authorization_code":"auth_code_1","code_verifier":"verifier_1"}"#,
)
} else if request.contains("/oauth/token") {
saw_exchange.store(true, Ordering::Relaxed);
- Self::json_response(500, r#"{"error":"exchange failed"}"#)
+ test_http::json_response(500, r#"{"error":"exchange failed"}"#)
} else {
- Self::json_response(404, r#"{"error":"not found"}"#)
+ test_http::json_response(404, r#"{"error":"not found"}"#)
}
}
fn handle_init_then_timeout(request: &str, saw_init: &AtomicBool) -> String {
if request.contains("/api/accounts/deviceauth/usercode") {
saw_init.store(true, Ordering::Relaxed);
- Self::json_response(
+ test_http::json_response(
200,
r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"99999"}"#,
)
} else {
// Return 403 to keep polling
- Self::json_response(403, r#"{"error":"pending"}"#)
+ test_http::json_response(403, r#"{"error":"pending"}"#)
}
}
-
- fn json_response(status: u16, body: &str) -> String {
- let reason = match status {
- 200 => "OK",
- 403 => "Forbidden",
- 404 => "Not Found",
- 500 => "Internal Server Error",
- _ => "Unknown",
- };
- format!(
- "HTTP/1.1 {status} {reason}\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",
- body.len(),
- )
- }
- }
-
- impl Drop for MockDeviceServer {
- fn drop(&mut self) {
- self.shutdown.store(true, Ordering::Relaxed);
- }
}
#[test]
fn device_flow_success_after_pending() {
let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::SuccessAfterPending);
- let client = DeviceAuthClient::with_issuer(&server.url);
+ let client = DeviceAuthClient::with_issuer(server.url());
let tokens = client.run().unwrap();
assert_eq!(tokens.access_token, "at_1");
assert_eq!(tokens.refresh_token, "rt_1");
@@ -527,7 +411,7 @@ mod tests {
fn device_flow_reports_init_failure() {
let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::InitFailure);
- let err = DeviceAuthClient::with_issuer(&server.url)
+ let err = DeviceAuthClient::with_issuer(server.url())
.run()
.unwrap_err();
assert!(
@@ -541,7 +425,7 @@ mod tests {
fn device_flow_reports_poll_failure() {
let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::PollFailure);
- let err = DeviceAuthClient::with_issuer(&server.url)
+ let err = DeviceAuthClient::with_issuer(server.url())
.run()
.unwrap_err();
assert!(
@@ -556,7 +440,7 @@ mod tests {
fn device_flow_reports_token_exchange_failure() {
let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::TokenExchangeFailure);
- let err = DeviceAuthClient::with_issuer(&server.url)
+ let err = DeviceAuthClient::with_issuer(server.url())
.run()
.unwrap_err();
assert!(
@@ -573,7 +457,7 @@ mod tests {
let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::InitThenTimeout);
let client = DeviceAuthClient {
- issuer: server.url.clone(),
+ issuer: server.url().to_string(),
client: reqwest::blocking::Client::builder()
.timeout(Duration::from_secs(5))
.build()
@@ -595,80 +479,49 @@ mod tests {
let saw_init = Arc::new(AtomicBool::new(false));
let saw_exchange = Arc::new(AtomicBool::new(false));
let saw_second_poll = Arc::new(AtomicBool::new(false));
- let shutdown = Arc::new(AtomicBool::new(false));
-
let si = saw_init.clone();
let sp403 = saw_poll_403.clone();
let sp2 = saw_second_poll.clone();
let ste = saw_exchange.clone();
- let sd = shutdown.clone();
let poll_count = Arc::new(std::sync::atomic::AtomicU32::new(0));
let pc = poll_count.clone();
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- let url = format!("http://{addr}");
- listener.set_nonblocking(true).expect("nonblocking");
- let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-
- std::thread::spawn(move || {
- let _ = ready_tx.send(());
- loop {
- if sd.load(Ordering::Relaxed) {
- return;
- }
- match listener.accept() {
- Ok((mut stream, _)) => {
- use std::io::Write;
- let Some(request) = read_http_request(&mut stream) else {
- continue;
- };
-
- let response = if request.contains("/api/accounts/deviceauth/usercode") {
- si.store(true, Ordering::Relaxed);
- json_response(
- 200,
- r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"1"}"#,
- )
- } else if request.contains("/api/accounts/deviceauth/token") {
- let count = pc.fetch_add(1, Ordering::Relaxed);
- if count == 0 {
- sp403.store(true, Ordering::Relaxed);
- json_response(403, r#"{"error":"pending"}"#)
- } else {
- sp2.store(true, Ordering::Relaxed);
- json_response(
- 200,
- r#"{"authorization_code":"ac_2","code_verifier":"cv_2"}"#,
- )
- }
- } else if request.contains("/oauth/token") {
- ste.store(true, Ordering::Relaxed);
- json_response(
- 200,
- r#"{"access_token":"at_2","refresh_token":"rt_2","expires_in":3600}"#,
- )
- } else {
- json_response(404, r#"{"error":"nf"}"#)
- };
-
- let _ = stream.write_all(response.as_bytes());
- let _ = stream.flush();
- }
- Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
- std::thread::sleep(Duration::from_millis(10));
+ let server = test_http::spawn_mock_server(
+ "mock device server should become ready",
+ move |request| {
+ if request.contains("/api/accounts/deviceauth/usercode") {
+ si.store(true, Ordering::Relaxed);
+ test_http::json_response(
+ 200,
+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"1"}"#,
+ )
+ } else if request.contains("/api/accounts/deviceauth/token") {
+ let count = pc.fetch_add(1, Ordering::Relaxed);
+ if count == 0 {
+ sp403.store(true, Ordering::Relaxed);
+ test_http::json_response(403, r#"{"error":"pending"}"#)
+ } else {
+ sp2.store(true, Ordering::Relaxed);
+ test_http::json_response(
+ 200,
+ r#"{"authorization_code":"ac_2","code_verifier":"cv_2"}"#,
+ )
}
- Err(_) => break,
+ } else if request.contains("/oauth/token") {
+ ste.store(true, Ordering::Relaxed);
+ test_http::json_response(
+ 200,
+ r#"{"access_token":"at_2","refresh_token":"rt_2","expires_in":3600}"#,
+ )
+ } else {
+ test_http::json_response(404, r#"{"error":"nf"}"#)
}
- }
- });
- ready_rx
- .recv_timeout(Duration::from_secs(1))
- .expect("mock device server should become ready");
+ },
+ );
let sleeper = MockSleeper::default();
let client = DeviceAuthClient {
- issuer: url,
+ issuer: server.url.clone(),
client: reqwest::blocking::Client::builder()
.timeout(Duration::from_secs(5))
.build()
@@ -682,7 +535,6 @@ mod tests {
assert!(saw_poll_403.load(Ordering::Relaxed));
assert!(saw_second_poll.load(Ordering::Relaxed));
assert!(saw_exchange.load(Ordering::Relaxed));
- shutdown.store(true, Ordering::Relaxed);
}
#[test]
@@ -691,78 +543,47 @@ mod tests {
let saw_init = Arc::new(AtomicBool::new(false));
let saw_poll_404 = Arc::new(AtomicBool::new(false));
let saw_exchange = Arc::new(AtomicBool::new(false));
- let shutdown = Arc::new(AtomicBool::new(false));
-
let si = saw_init.clone();
let sp404 = saw_poll_404.clone();
let ste = saw_exchange.clone();
- let sd = shutdown.clone();
let poll_count = Arc::new(std::sync::atomic::AtomicU32::new(0));
let pc = poll_count.clone();
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- let url = format!("http://{addr}");
- listener.set_nonblocking(true).expect("nonblocking");
- let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-
- std::thread::spawn(move || {
- let _ = ready_tx.send(());
- loop {
- if sd.load(Ordering::Relaxed) {
- return;
- }
- match listener.accept() {
- Ok((mut stream, _)) => {
- use std::io::Write;
- let Some(request) = read_http_request(&mut stream) else {
- continue;
- };
-
- let response = if request.contains("/api/accounts/deviceauth/usercode") {
- si.store(true, Ordering::Relaxed);
- json_response(
- 200,
- r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"1"}"#,
- )
- } else if request.contains("/api/accounts/deviceauth/token") {
- let count = pc.fetch_add(1, Ordering::Relaxed);
- if count == 0 {
- sp404.store(true, Ordering::Relaxed);
- json_response(404, r#"{"error":"nf"}"#)
- } else {
- json_response(
- 200,
- r#"{"authorization_code":"ac_3","code_verifier":"cv_3"}"#,
- )
- }
- } else if request.contains("/oauth/token") {
- ste.store(true, Ordering::Relaxed);
- json_response(
- 200,
- r#"{"access_token":"at_3","refresh_token":"rt_3","expires_in":3600}"#,
- )
- } else {
- json_response(404, r#"{"error":"nf"}"#)
- };
-
- let _ = stream.write_all(response.as_bytes());
- let _ = stream.flush();
+ let server = test_http::spawn_mock_server(
+ "mock device server should become ready",
+ move |request| {
+ if request.contains("/api/accounts/deviceauth/usercode") {
+ si.store(true, Ordering::Relaxed);
+ test_http::json_response(
+ 200,
+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"1"}"#,
+ )
+ } else if request.contains("/api/accounts/deviceauth/token") {
+ let count = pc.fetch_add(1, Ordering::Relaxed);
+ if count == 0 {
+ sp404.store(true, Ordering::Relaxed);
+ test_http::json_response(404, r#"{"error":"nf"}"#)
+ } else {
+ test_http::json_response(
+ 200,
+ r#"{"authorization_code":"ac_3","code_verifier":"cv_3"}"#,
+ )
}
- Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
- std::thread::sleep(Duration::from_millis(10));
- }
- Err(_) => break,
+ } else if request.contains("/oauth/token") {
+ ste.store(true, Ordering::Relaxed);
+ test_http::json_response(
+ 200,
+ r#"{"access_token":"at_3","refresh_token":"rt_3","expires_in":3600}"#,
+ )
+ } else {
+ test_http::json_response(404, r#"{"error":"nf"}"#)
}
- }
- });
- ready_rx
- .recv_timeout(Duration::from_secs(1))
- .expect("mock device server should become ready");
+ },
+ );
let sleeper = MockSleeper::default();
let client = DeviceAuthClient {
- issuer: url,
+ issuer: server.url.clone(),
client: reqwest::blocking::Client::builder()
.timeout(Duration::from_secs(5))
.build()
@@ -775,7 +596,6 @@ mod tests {
assert!(saw_init.load(Ordering::Relaxed));
assert!(saw_poll_404.load(Ordering::Relaxed));
assert!(saw_exchange.load(Ordering::Relaxed));
- shutdown.store(true, Ordering::Relaxed);
}
#[test]
diff --git a/src/providers/codex/auth/mod.rs b/src/providers/codex/auth/mod.rs
index 239f7db..98c7443 100644
--- a/src/providers/codex/auth/mod.rs
+++ b/src/providers/codex/auth/mod.rs
@@ -4,4 +4,6 @@ pub mod device;
pub mod jwt;
pub mod manager;
pub mod pkce;
+#[cfg(test)]
+pub(crate) mod test_http;
pub mod token_store;
diff --git a/src/providers/codex/auth/test_http.rs b/src/providers/codex/auth/test_http.rs
new file mode 100644
index 0000000..39af054
--- /dev/null
+++ b/src/providers/codex/auth/test_http.rs
@@ -0,0 +1,132 @@
+use std::io::{Read, Write};
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+
+pub(crate) struct MockServer {
+ pub(crate) url: String,
+ shutdown: Arc<AtomicBool>,
+}
+
+impl Drop for MockServer {
+ fn drop(&mut self) {
+ self.shutdown.store(true, Ordering::Relaxed);
+ }
+}
+
+pub(crate) fn spawn_mock_server<F>(ready_message: &'static str, handler: F) -> MockServer
+where
+ F: Fn(&str) -> String + Send + Sync + 'static,
+{
+ let shutdown = Arc::new(AtomicBool::new(false));
+ let sd = shutdown.clone();
+ let handler = Arc::new(handler);
+ let listener = TcpListener::bind("127.0.0.1:0").expect("bind test server");
+ let addr = listener.local_addr().unwrap();
+ let url = format!("http://{addr}");
+ listener.set_nonblocking(true).expect("set nonblocking");
+ let (ready_tx, ready_rx) = std::sync::mpsc::channel();
+
+ std::thread::spawn(move || {
+ let _ = ready_tx.send(());
+ loop {
+ if sd.load(Ordering::Relaxed) {
+ return;
+ }
+ match listener.accept() {
+ Ok((mut stream, _)) => {
+ let Some(request) = read_http_request(&mut stream) else {
+ continue;
+ };
+ let response = handler(&request);
+ let _ = stream.write_all(response.as_bytes());
+ let _ = stream.flush();
+ }
+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
+ std::thread::sleep(Duration::from_millis(10));
+ }
+ Err(_) => break,
+ }
+ }
+ });
+ ready_rx
+ .recv_timeout(Duration::from_secs(1))
+ .expect(ready_message);
+
+ MockServer { url, shutdown }
+}
+
+pub(crate) fn json_response(status: u16, body: &str) -> String {
+ response(status, "application/json", body)
+}
+
+pub(crate) fn response(status: u16, content_type: &str, body: &str) -> String {
+ let reason = match status {
+ 200 => "OK",
+ 400 => "Bad Request",
+ 403 => "Forbidden",
+ 404 => "Not Found",
+ 500 => "Internal Server Error",
+ _ => "Unknown",
+ };
+ format!(
+ "HTTP/1.1 {status} {reason}\r\nContent-Length: {}\r\nContent-Type: {content_type}\r\nConnection: close\r\n\r\n{body}",
+ body.len(),
+ )
+}
+
+pub(crate) fn send_get(addr: SocketAddr, path: &str) -> String {
+ let mut stream = TcpStream::connect(addr).unwrap();
+ let request = format!("GET {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n");
+ let _ = stream.write_all(request.as_bytes());
+ let _ = stream.flush();
+
+ let mut buf = vec![0u8; 4096];
+ let n = stream.read(&mut buf).unwrap_or(0);
+ String::from_utf8_lossy(&buf[..n]).to_string()
+}
+
+pub(crate) fn read_http_request(stream: &mut TcpStream) -> Option<String> {
+ let _ = stream.set_nonblocking(false);
+ let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
+ let mut request = Vec::new();
+ let mut chunk = [0; 4096];
+
+ loop {
+ let n = stream.read(&mut chunk).ok()?;
+ if n == 0 {
+ break;
+ }
+ request.extend_from_slice(&chunk[..n]);
+
+ if let Some(header_end) = find_header_end(&request) {
+ let content_length = content_length(&request[..header_end]).unwrap_or(0);
+ if request.len() >= header_end + 4 + content_length {
+ break;
+ }
+ }
+ }
+
+ if request.is_empty() {
+ None
+ } else {
+ Some(String::from_utf8_lossy(&request).to_string())
+ }
+}
+
+fn find_header_end(bytes: &[u8]) -> Option<usize> {
+ bytes.windows(4).position(|window| window == b"\r\n\r\n")
+}
+
+fn content_length(headers: &[u8]) -> Option<usize> {
+ let text = String::from_utf8_lossy(headers);
+ text.lines().find_map(|line| {
+ let (name, value) = line.split_once(':')?;
+ if name.eq_ignore_ascii_case("content-length") {
+ value.trim().parse().ok()
+ } else {
+ None
+ }
+ })
+}
diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rs
index 4d880b7..3e60fd0 100644
--- a/src/providers/codex/translate/request.rs
+++ b/src/providers/codex/translate/request.rs
@@ -3,6 +3,9 @@ use serde_json::Value;
use crate::anthropic::schema::MessagesRequest;
use crate::config;
+use crate::providers::translate_shared::{
+ ContentBlock, flatten_system_text, image_source_to_url, normalize_content, read_effort,
+};
// ---------------------------------------------------------------------------
// Types
@@ -324,48 +327,6 @@ pub fn translate_request(
// Helpers
// ---------------------------------------------------------------------------
-fn flatten_system_text(system: Option<&Value>) -> Option<String> {
- let system = system?;
- let texts: Vec<String> = match system {
- Value::String(s) => vec![s.clone()],
- Value::Array(arr) => arr
- .iter()
- .filter_map(|b| {
- let text = b.get("text").and_then(|v| v.as_str())?;
- if text.starts_with("x-anthropic-billing-header:") {
- None
- } else {
- Some(text.to_string())
- }
- })
- .collect(),
- _ => return None,
- };
- if texts.is_empty() {
- None
- } else {
- Some(texts.join("\n\n"))
- }
-}
-
-fn read_effort(req: &MessagesRequest) -> Result<Option<&str>, anyhow::Error> {
- let output_config = match req.extra.get("output_config") {
- Some(Value::Object(m)) => m,
- _ => return Ok(None),
- };
- match output_config.get("effort") {
- Some(Value::String(s)) => {
- let valid = ["low", "medium", "high", "max"];
- if valid.contains(&s.as_str()) {
- Ok(Some(s.as_str()))
- } else {
- anyhow::bail!("Invalid output_config.effort: {s}")
- }
- }
- _ => Ok(None),
- }
-}
-
fn read_output_format(req: &MessagesRequest) -> Option<ResponsesTextFormat> {
let output_config = req.extra.get("output_config")?.as_object()?;
let format = output_config.get("format")?.as_object()?;
@@ -512,7 +473,7 @@ fn build_input(req: &MessagesRequest) -> Vec<ResponsesInputItem> {
let mut out: Vec<ResponsesInputItem> = Vec::new();
for msg in &req.messages {
- let blocks = normalize_content(&msg.content);
+ let blocks = normalize_content(&msg.content, Value::Null);
match msg.role.as_str() {
"user" => {
let mut parts: Vec<ResponsesContentPart> = Vec::new();
@@ -522,13 +483,8 @@ fn build_input(req: &MessagesRequest) -> Vec<ResponsesInputItem> {
parts.push(ResponsesContentPart::InputText { text: text.clone() });
}
ContentBlock::Image { source } => {
- let url = if source.source_type == "url" {
- source.data.clone()
- } else {
- format!("data:{};base64,{}", source.media_type, source.data)
- };
parts.push(ResponsesContentPart::InputImage {
- image_url: url,
+ image_url: image_source_to_url(source),
detail: None,
});
}
@@ -621,126 +577,9 @@ fn build_input(req: &MessagesRequest) -> Vec<ResponsesInputItem> {
}
// ---------------------------------------------------------------------------
-// Content block normalization
+// Tool result rendering
// ---------------------------------------------------------------------------
-#[derive(Debug)]
-pub enum ContentBlock {
- Text {
- text: String,
- },
- Image {
- source: ImageSource,
- },
- ToolUse {
- id: String,
- name: String,
- input: Value,
- },
- ToolResult {
- tool_use_id: String,
- content: Value,
- is_error: Option<bool>,
- },
-}
-
-#[derive(Debug)]
-pub struct ImageSource {
- pub media_type: String,
- pub data: String,
- pub source_type: String,
-}
-
-fn normalize_content(content: &Value) -> Vec<ContentBlock> {
- match content {
- Value::String(s) => {
- vec![ContentBlock::Text { text: s.clone() }]
- }
- Value::Array(arr) => {
- let mut blocks = Vec::new();
- for item in arr {
- if let Some(block) = parse_content_block(item) {
- blocks.push(block);
- }
- }
- blocks
- }
- _ => Vec::new(),
- }
-}
-
-fn parse_content_block(value: &Value) -> Option<ContentBlock> {
- let kind = value.get("type").and_then(|v| v.as_str())?;
- match kind {
- "text" => {
- let text = value
- .get("text")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- Some(ContentBlock::Text { text })
- }
- "image" => {
- let source = value.get("source")?;
- let media_type = source
- .get("media_type")
- .and_then(|v| v.as_str())
- .unwrap_or("image/png")
- .to_string();
- let source_type = source
- .get("type")
- .and_then(|v| v.as_str())
- .unwrap_or("base64")
- .to_string();
- let data = if source_type == "url" {
- source.get("url").and_then(|v| v.as_str()).unwrap_or("")
- } else {
- source.get("data").and_then(|v| v.as_str()).unwrap_or("")
- }
- .to_string();
- Some(ContentBlock::Image {
- source: ImageSource {
- media_type,
- data,
- source_type,
- },
- })
- }
- "tool_use" => {
- let id = value
- .get("id")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- let name = value
- .get("name")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- let input = value.get("input").cloned().unwrap_or(Value::Null);
- Some(ContentBlock::ToolUse { id, name, input })
- }
- "tool_result" => {
- let tool_use_id = value
- .get("tool_use_id")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- let content = value
- .get("content")
- .cloned()
- .unwrap_or(Value::String(String::new()));
- let is_error = value.get("is_error").and_then(|v| v.as_bool());
- Some(ContentBlock::ToolResult {
- tool_use_id,
- content,
- is_error,
- })
- }
- _ => None,
- }
-}
-
fn tool_result_to_string(content: &Value) -> String {
match content {
Value::String(s) => s.clone(),
diff --git a/src/providers/codex/translate/stream.rs b/src/providers/codex/translate/stream.rs
index 01b5862..aec8f05 100644
--- a/src/providers/codex/translate/stream.rs
+++ b/src/providers/codex/translate/stream.rs
@@ -1,3 +1,5 @@
+use std::collections::BTreeMap;
+
use crate::anthropic::sse::encode_sse_event;
use crate::traffic::TrafficCapture;
@@ -6,6 +8,184 @@ use super::reducer::{
};
use super::web_search_compat::build_web_search_compat_blocks;
+#[allow(dead_code)]
+enum OpenBlock {
+ Text,
+ Tool { id: String, name: String },
+}
+
+fn emit(
+ out: &mut Vec<u8>,
+ traffic: Option<&TrafficCapture>,
+ event: &str,
+ data: &serde_json::Value,
+) {
+ if let Some(traffic) = traffic {
+ traffic.write_json_event(
+ "050-downstream-event",
+ &serde_json::json!({
+ "event": event,
+ "data": data,
+ }),
+ );
+ }
+ out.extend_from_slice(&encode_sse_event(Some(event), &data.to_string()));
+}
+
+fn ensure_message_start(
+ out: &mut Vec<u8>,
+ traffic: Option<&TrafficCapture>,
+ message_started: &mut bool,
+ message_id: &str,
+ model: &str,
+) {
+ if !*message_started {
+ *message_started = true;
+ let data = serde_json::json!({
+ "type": "message_start",
+ "message": {
+ "id": message_id,
+ "type": "message",
+ "role": "assistant",
+ "model": model,
+ "content": [],
+ "stop_reason": null,
+ "stop_sequence": null,
+ "usage": {
+ "input_tokens": 0,
+ "output_tokens": 0,
+ }
+ }
+ });
+ emit(out, traffic, "message_start", &data);
+ }
+}
+
+fn emit_content_event(
+ out: &mut Vec<u8>,
+ traffic: Option<&TrafficCapture>,
+ message_started: &mut bool,
+ open_blocks: &mut BTreeMap<usize, OpenBlock>,
+ message_id: &str,
+ model: &str,
+ event: &ReducerEvent,
+) -> bool {
+ match event {
+ ReducerEvent::TextStart { index } => {
+ ensure_message_start(out, traffic, message_started, message_id, model);
+ open_blocks.insert(*index, OpenBlock::Text);
+ emit(
+ out,
+ traffic,
+ "content_block_start",
+ &serde_json::json!({
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {"type": "text", "text": ""}
+ }),
+ );
+ true
+ }
+ ReducerEvent::TextDelta { index, text } => {
+ emit(
+ out,
+ traffic,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {"type": "text_delta", "text": text}
+ }),
+ );
+ true
+ }
+ ReducerEvent::TextStop { index } => {
+ open_blocks.remove(index);
+ emit(
+ out,
+ traffic,
+ "content_block_stop",
+ &serde_json::json!({
+ "type": "content_block_stop",
+ "index": index,
+ }),
+ );
+ true
+ }
+ ReducerEvent::ToolStart { index, id, name } => {
+ ensure_message_start(out, traffic, message_started, message_id, model);
+ open_blocks.insert(
+ *index,
+ OpenBlock::Tool {
+ id: id.clone(),
+ name: name.clone(),
+ },
+ );
+ emit(
+ out,
+ traffic,
+ "content_block_start",
+ &serde_json::json!({
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {
+ "type": "tool_use",
+ "id": id,
+ "name": name,
+ "input": {}
+ }
+ }),
+ );
+ true
+ }
+ ReducerEvent::ToolDelta {
+ index,
+ partial_json,
+ } => {
+ emit(
+ out,
+ traffic,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {
+ "type": "input_json_delta",
+ "partial_json": partial_json
+ }
+ }),
+ );
+ true
+ }
+ ReducerEvent::ToolStop { index } => {
+ open_blocks.remove(index);
+ emit(
+ out,
+ traffic,
+ "content_block_stop",
+ &serde_json::json!({
+ "type": "content_block_stop",
+ "index": index,
+ }),
+ );
+ true
+ }
+ _ => false,
+ }
+}
+
+fn is_content_event(event: &ReducerEvent) -> bool {
+ matches!(
+ event,
+ ReducerEvent::TextStart { .. }
+ | ReducerEvent::TextDelta { .. }
+ | ReducerEvent::TextStop { .. }
+ | ReducerEvent::ToolStart { .. }
+ | ReducerEvent::ToolDelta { .. }
+ | ReducerEvent::ToolStop { .. }
+ )
+}
+
pub fn translate_stream_bytes(
upstream: &[u8],
message_id: &str,
@@ -34,71 +214,10 @@ pub fn translate_stream_bytes_with_traffic(
let mut out = Vec::new();
let mut message_started = false;
- let mut open_blocks: std::collections::BTreeMap<usize, OpenBlock> =
- std::collections::BTreeMap::new();
+ let mut open_blocks: BTreeMap<usize, OpenBlock> = BTreeMap::new();
let mut web_search_events: Vec<ReducerEvent> = Vec::new();
let mut deferred_content_events: Vec<ReducerEvent> = Vec::new();
- #[allow(dead_code)]
- enum OpenBlock {
- Text,
- Tool { id: String, name: String },
- }
-
- let mut emit = |event: &str, data: &serde_json::Value| -> Result<(), anyhow::Error> {
- if let Some(traffic) = traffic {
- traffic.write_json_event(
- "050-downstream-event",
- &serde_json::json!({
- "event": event,
- "data": data,
- }),
- );
- }
- out.extend_from_slice(&encode_sse_event(Some(event), &data.to_string()));
- Ok(())
- };
-
- let mut ensure_message_start = |emit: &mut dyn FnMut(
- &str,
- &serde_json::Value,
- ) -> Result<(), anyhow::Error>|
- -> Result<(), anyhow::Error> {
- if !message_started {
- message_started = true;
- let data = serde_json::json!({
- "type": "message_start",
- "message": {
- "id": message_id,
- "type": "message",
- "role": "assistant",
- "model": model,
- "content": [],
- "stop_reason": null,
- "stop_sequence": null,
- "usage": {
- "input_tokens": 0,
- "output_tokens": 0,
- }
- }
- });
- emit("message_start", &data)?;
- }
- Ok(())
- };
-
- let is_content_event = |event: &ReducerEvent| -> bool {
- matches!(
- event,
- ReducerEvent::TextStart { .. }
- | ReducerEvent::TextDelta { .. }
- | ReducerEvent::TextStop { .. }
- | ReducerEvent::ToolStart { .. }
- | ReducerEvent::ToolDelta { .. }
- | ReducerEvent::ToolStop { .. }
- )
- };
-
for event in &events {
if matches!(event, ReducerEvent::WebSearch { .. }) {
web_search_events.push(event.clone());
@@ -109,91 +228,20 @@ pub fn translate_stream_bytes_with_traffic(
continue;
}
+ if emit_content_event(
+ &mut out,
+ traffic,
+ &mut message_started,
+ &mut open_blocks,
+ message_id,
+ model,
+ event,
+ ) {
+ continue;
+ }
+
match event {
- ReducerEvent::TextStart { index } => {
- ensure_message_start(&mut emit)?;
- open_blocks.insert(*index, OpenBlock::Text);
- emit(
- "content_block_start",
- &serde_json::json!({
- "type": "content_block_start",
- "index": index,
- "content_block": {"type": "text", "text": ""}
- }),
- )?;
- }
- ReducerEvent::TextDelta { index, text } => {
- emit(
- "content_block_delta",
- &serde_json::json!({
- "type": "content_block_delta",
- "index": index,
- "delta": {"type": "text_delta", "text": text}
- }),
- )?;
- }
- ReducerEvent::TextStop { index } => {
- open_blocks.remove(index);
- emit(
- "content_block_stop",
- &serde_json::json!({
- "type": "content_block_stop",
- "index": index,
- }),
- )?;
- }
- ReducerEvent::ToolStart { index, id, name } => {
- ensure_message_start(&mut emit)?;
- open_blocks.insert(
- *index,
- OpenBlock::Tool {
- id: id.clone(),
- name: name.clone(),
- },
- );
- emit(
- "content_block_start",
- &serde_json::json!({
- "type": "content_block_start",
- "index": index,
- "content_block": {
- "type": "tool_use",
- "id": id,
- "name": name,
- "input": {}
- }
- }),
- )?;
- }
- ReducerEvent::ToolDelta {
- index,
- partial_json,
- } => {
- emit(
- "content_block_delta",
- &serde_json::json!({
- "type": "content_block_delta",
- "index": index,
- "delta": {
- "type": "input_json_delta",
- "partial_json": partial_json
- }
- }),
- )?;
- }
- ReducerEvent::ToolStop { index } => {
- open_blocks.remove(index);
- emit(
- "content_block_stop",
- &serde_json::json!({
- "type": "content_block_stop",
- "index": index,
- }),
- )?;
- }
- ReducerEvent::ToolProgress { .. } | ReducerEvent::Progress => {
- // These are just progress indicators; emit nothing in buffered mode
- }
+ ReducerEvent::ToolProgress { .. } | ReducerEvent::Progress => {}
ReducerEvent::Finish {
stop_reason,
usage,
@@ -215,8 +263,16 @@ pub fn translate_stream_bytes_with_traffic(
use super::web_search_compat::WebSearchCompatContent;
match &block.content {
WebSearchCompatContent::ServerToolUse { id, name, input } => {
- ensure_message_start(&mut emit)?;
+ ensure_message_start(
+ &mut out,
+ traffic,
+ &mut message_started,
+ message_id,
+ model,
+ );
emit(
+ &mut out,
+ traffic,
"content_block_start",
&serde_json::json!({
"type": "content_block_start",
@@ -228,8 +284,10 @@ pub fn translate_stream_bytes_with_traffic(
"input": {}
}
}),
- )?;
+ );
emit(
+ &mut out,
+ traffic,
"content_block_delta",
&serde_json::json!({
"type": "content_block_delta",
@@ -239,14 +297,16 @@ pub fn translate_stream_bytes_with_traffic(
"partial_json": serde_json::to_string(input).unwrap_or_default()
}
}),
- )?;
+ );
emit(
+ &mut out,
+ traffic,
"content_block_stop",
&serde_json::json!({
"type": "content_block_stop",
"index": block.index,
}),
- )?;
+ );
}
WebSearchCompatContent::WebSearchToolResult {
tool_use_id,
@@ -263,6 +323,8 @@ pub fn translate_stream_bytes_with_traffic(
})
.collect();
emit(
+ &mut out,
+ traffic,
"content_block_start",
&serde_json::json!({
"type": "content_block_start",
@@ -273,14 +335,16 @@ pub fn translate_stream_bytes_with_traffic(
"content": result_content,
}
}),
- )?;
+ );
emit(
+ &mut out,
+ traffic,
"content_block_stop",
&serde_json::json!({
"type": "content_block_stop",
"index": block.index,
}),
- )?;
+ );
}
}
}
@@ -288,96 +352,23 @@ pub fn translate_stream_bytes_with_traffic(
// Emit deferred content
for deferred in &deferred_content_events {
- match deferred {
- ReducerEvent::TextStart { index } => {
- ensure_message_start(&mut emit)?;
- open_blocks.insert(*index, OpenBlock::Text);
- emit(
- "content_block_start",
- &serde_json::json!({
- "type": "content_block_start",
- "index": index,
- "content_block": {"type": "text", "text": ""}
- }),
- )?;
- }
- ReducerEvent::TextDelta { index, text } => {
- emit(
- "content_block_delta",
- &serde_json::json!({
- "type": "content_block_delta",
- "index": index,
- "delta": {"type": "text_delta", "text": text}
- }),
- )?;
- }
- ReducerEvent::TextStop { index } => {
- open_blocks.remove(index);
- emit(
- "content_block_stop",
- &serde_json::json!({
- "type": "content_block_stop",
- "index": index,
- }),
- )?;
- }
- ReducerEvent::ToolStart { index, id, name } => {
- ensure_message_start(&mut emit)?;
- open_blocks.insert(
- *index,
- OpenBlock::Tool {
- id: id.clone(),
- name: name.clone(),
- },
- );
- emit(
- "content_block_start",
- &serde_json::json!({
- "type": "content_block_start",
- "index": index,
- "content_block": {
- "type": "tool_use",
- "id": id,
- "name": name,
- "input": {}
- }
- }),
- )?;
- }
- ReducerEvent::ToolDelta {
- index,
- partial_json,
- } => {
- emit(
- "content_block_delta",
- &serde_json::json!({
- "type": "content_block_delta",
- "index": index,
- "delta": {
- "type": "input_json_delta",
- "partial_json": partial_json
- }
- }),
- )?;
- }
- ReducerEvent::ToolStop { index } => {
- open_blocks.remove(index);
- emit(
- "content_block_stop",
- &serde_json::json!({
- "type": "content_block_stop",
- "index": index,
- }),
- )?;
- }
- _ => {}
- }
+ emit_content_event(
+ &mut out,
+ traffic,
+ &mut message_started,
+ &mut open_blocks,
+ message_id,
+ model,
+ deferred,
+ );
}
- ensure_message_start(&mut emit)?;
+ ensure_message_start(&mut out, traffic, &mut message_started, message_id, model);
let mapped = map_codex_usage_to_anthropic(usage, Some(*web_search_requests));
emit(
+ &mut out,
+ traffic,
"message_delta",
&serde_json::json!({
"type": "message_delta",
@@ -387,8 +378,13 @@ pub fn translate_stream_bytes_with_traffic(
},
"usage": mapped,
}),
- )?;
- emit("message_stop", &serde_json::json!({"type": "message_stop"}))?;
+ );
+ emit(
+ &mut out,
+ traffic,
+ "message_stop",
+ &serde_json::json!({"type": "message_stop"}),
+ );
}
_ => {}
}
diff --git a/src/providers/cursor/mod.rs b/src/providers/cursor/mod.rs
index e2842a0..9d2d0d0 100644
--- a/src/providers/cursor/mod.rs
+++ b/src/providers/cursor/mod.rs
@@ -6,6 +6,8 @@ pub mod proto;
pub mod request;
pub mod response;
pub mod sse;
+#[cfg(test)]
+pub(crate) mod test_frames;
pub mod tool_bridge;
pub mod tool_use_xml;
diff --git a/src/providers/cursor/response.rs b/src/providers/cursor/response.rs
index 7e87765..e2867aa 100644
--- a/src/providers/cursor/response.rs
+++ b/src/providers/cursor/response.rs
@@ -168,54 +168,16 @@ mod tests {
use super::*;
use crate::providers::cursor::connect::encode_connect_frame;
use crate::providers::cursor::proto::*;
+ use crate::providers::cursor::test_frames;
use prost::Message;
- fn make_text_frame(text: &str) -> Vec<u8> {
- let msg = AgentServerMessage {
- interaction_update: Some(InteractionUpdate {
- thinking_delta: None,
- text_delta: Some(TextDelta {
- text: text.to_string(),
- }),
- turn_ended: None,
- }),
- exec_server_message: None,
- };
- let mut payload = Vec::new();
- msg.encode(&mut payload).unwrap();
- encode_connect_frame(&payload, 0).to_vec()
- }
-
- fn make_usage_frame(input: u64, output: u64) -> Vec<u8> {
- let msg = AgentServerMessage {
- interaction_update: Some(InteractionUpdate {
- thinking_delta: None,
- text_delta: None,
- turn_ended: Some(TurnEnded {
- input_tokens: input,
- output_tokens: output,
- cache_read_tokens: 0,
- cache_write_tokens: 0,
- }),
- }),
- exec_server_message: None,
- };
- let mut payload = Vec::new();
- msg.encode(&mut payload).unwrap();
- encode_connect_frame(&payload, 0).to_vec()
- }
-
- fn make_end_frame() -> Vec<u8> {
- encode_connect_frame(b"", 2).to_vec()
- }
-
#[test]
fn decodes_text_and_usage_events() {
let mut body = Vec::new();
- body.extend_from_slice(&make_text_frame("Hello"));
- body.extend_from_slice(&make_text_frame(" world"));
- body.extend_from_slice(&make_usage_frame(10, 5));
- body.extend_from_slice(&make_end_frame());
+ body.extend_from_slice(&test_frames::text_frame("Hello"));
+ body.extend_from_slice(&test_frames::text_frame(" world"));
+ body.extend_from_slice(&test_frames::usage_frame(10, 5));
+ body.extend_from_slice(&test_frames::end_frame());
let events = decode_upstream_response(&body).unwrap();
assert_eq!(events.len(), 5);
@@ -228,19 +190,7 @@ mod tests {
#[test]
fn decodes_thinking_delta() {
- let msg = AgentServerMessage {
- interaction_update: Some(InteractionUpdate {
- thinking_delta: Some(ThinkingDelta {
- text: "thinking...".to_string(),
- }),
- text_delta: None,
- turn_ended: None,
- }),
- exec_server_message: None,
- };
- let mut payload = Vec::new();
- msg.encode(&mut payload).unwrap();
- let body = encode_connect_frame(&payload, 0).to_vec();
+ let body = test_frames::thinking_frame("thinking...");
let events = decode_upstream_response(&body).unwrap();
assert_eq!(events.len(), 1);
@@ -275,9 +225,9 @@ mod tests {
#[test]
fn accumulate_response_produces_anthropic_json() {
let mut body = Vec::new();
- body.extend_from_slice(&make_text_frame("Hello world"));
- body.extend_from_slice(&make_usage_frame(15, 3));
- body.extend_from_slice(&make_end_frame());
+ body.extend_from_slice(&test_frames::text_frame("Hello world"));
+ body.extend_from_slice(&test_frames::usage_frame(15, 3));
+ body.extend_from_slice(&test_frames::end_frame());
let upstream = CursorUpstreamResponse {
status: 200,
@@ -324,10 +274,10 @@ mod tests {
#[test]
fn multiple_text_deltas_accumulate() {
let mut body = Vec::new();
- body.extend_from_slice(&make_text_frame("Hello "));
- body.extend_from_slice(&make_text_frame("world"));
- body.extend_from_slice(&make_usage_frame(10, 2));
- body.extend_from_slice(&make_end_frame());
+ body.extend_from_slice(&test_frames::text_frame("Hello "));
+ body.extend_from_slice(&test_frames::text_frame("world"));
+ body.extend_from_slice(&test_frames::usage_frame(10, 2));
+ body.extend_from_slice(&test_frames::end_frame());
let events = decode_upstream_response(&body).unwrap();
let text: String = events
diff --git a/src/providers/cursor/sse.rs b/src/providers/cursor/sse.rs
index 98004cd..c541260 100644
--- a/src/providers/cursor/sse.rs
+++ b/src/providers/cursor/sse.rs
@@ -359,55 +359,14 @@ impl<'a> CursorSseFramer<'a> {
#[cfg(test)]
mod tests {
use super::*;
- use crate::providers::cursor::connect::encode_connect_frame;
- use crate::providers::cursor::proto::*;
- use prost::Message;
-
- fn make_text_frame(text: &str) -> Vec<u8> {
- let msg = AgentServerMessage {
- interaction_update: Some(InteractionUpdate {
- thinking_delta: None,
- text_delta: Some(TextDelta {
- text: text.to_string(),
- }),
- turn_ended: None,
- }),
- exec_server_message: None,
- };
- let mut payload = Vec::new();
- msg.encode(&mut payload).unwrap();
- encode_connect_frame(&payload, 0).to_vec()
- }
-
- fn make_usage_frame(input: u64, output: u64) -> Vec<u8> {
- let msg = AgentServerMessage {
- interaction_update: Some(InteractionUpdate {
- thinking_delta: None,
- text_delta: None,
- turn_ended: Some(TurnEnded {
- input_tokens: input,
- output_tokens: output,
- cache_read_tokens: 0,
- cache_write_tokens: 0,
- }),
- }),
- exec_server_message: None,
- };
- let mut payload = Vec::new();
- msg.encode(&mut payload).unwrap();
- encode_connect_frame(&payload, 0).to_vec()
- }
-
- fn make_end_frame() -> Vec<u8> {
- encode_connect_frame(b"", 2).to_vec()
- }
+ use crate::providers::cursor::test_frames;
#[test]
fn sse_produces_message_start_and_stop() {
let mut body = Vec::new();
- body.extend_from_slice(&make_text_frame("hello"));
- body.extend_from_slice(&make_usage_frame(10, 5));
- body.extend_from_slice(&make_end_frame());
+ body.extend_from_slice(&test_frames::text_frame("hello"));
+ body.extend_from_slice(&test_frames::usage_frame(10, 5));
+ body.extend_from_slice(&test_frames::end_frame());
let upstream = CursorUpstreamResponse {
status: 200,
@@ -438,9 +397,9 @@ mod tests {
#[test]
fn sse_includes_text_delta_content() {
let mut body = Vec::new();
- body.extend_from_slice(&make_text_frame("Hello world"));
- body.extend_from_slice(&make_usage_frame(10, 2));
- body.extend_from_slice(&make_end_frame());
+ body.extend_from_slice(&test_frames::text_frame("Hello world"));
+ body.extend_from_slice(&test_frames::usage_frame(10, 2));
+ body.extend_from_slice(&test_frames::end_frame());
let upstream = CursorUpstreamResponse {
status: 200,
@@ -463,9 +422,9 @@ mod tests {
#[test]
fn sse_includes_usage_in_message_delta() {
let mut body = Vec::new();
- body.extend_from_slice(&make_text_frame("hi"));
- body.extend_from_slice(&make_usage_frame(25, 7));
- body.extend_from_slice(&make_end_frame());
+ body.extend_from_slice(&test_frames::text_frame("hi"));
+ body.extend_from_slice(&test_frames::usage_frame(25, 7));
+ body.extend_from_slice(&test_frames::end_frame());
let upstream = CursorUpstreamResponse {
status: 200,
@@ -512,24 +471,11 @@ mod tests {
#[test]
fn sse_emits_thinking_before_text() {
- // Build a response with thinking delta then text delta
- let thinking_msg = AgentServerMessage {
- interaction_update: Some(InteractionUpdate {
- thinking_delta: Some(ThinkingDelta {
- text: "thinking...".to_string(),
- }),
- text_delta: None,
- turn_ended: None,
- }),
- exec_server_message: None,
- };
- let mut payload = Vec::new();
- thinking_msg.encode(&mut payload).unwrap();
- let mut body: Vec<u8> = encode_connect_frame(&payload, 0).to_vec();
+ let mut body = test_frames::thinking_frame("thinking...");
- body.extend_from_slice(&make_text_frame("result"));
- body.extend_from_slice(&make_usage_frame(10, 5));
- body.extend_from_slice(&make_end_frame());
+ body.extend_from_slice(&test_frames::text_frame("result"));
+ body.extend_from_slice(&test_frames::usage_frame(10, 5));
+ body.extend_from_slice(&test_frames::end_frame());
let upstream = CursorUpstreamResponse {
status: 200,
diff --git a/src/providers/cursor/test_frames.rs b/src/providers/cursor/test_frames.rs
new file mode 100644
index 0000000..eb5649b
--- /dev/null
+++ b/src/providers/cursor/test_frames.rs
@@ -0,0 +1,65 @@
+use prost::Message;
+
+use super::connect::encode_connect_frame;
+use super::proto::{AgentServerMessage, InteractionUpdate, TextDelta, ThinkingDelta, TurnEnded};
+
+pub(crate) fn text_frame(text: &str) -> Vec<u8> {
+ encode_agent_message(AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: text.to_string(),
+ }),
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ })
+}
+
+pub(crate) fn thinking_frame(text: &str) -> Vec<u8> {
+ encode_agent_message(AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: Some(ThinkingDelta {
+ text: text.to_string(),
+ }),
+ text_delta: None,
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ })
+}
+
+pub(crate) fn usage_frame(input: u64, output: u64) -> Vec<u8> {
+ usage_frame_full(input, output, 0, 0)
+}
+
+pub(crate) fn usage_frame_full(
+ input: u64,
+ output: u64,
+ cache_read: u64,
+ cache_write: u64,
+) -> Vec<u8> {
+ encode_agent_message(AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: None,
+ turn_ended: Some(TurnEnded {
+ input_tokens: input,
+ output_tokens: output,
+ cache_read_tokens: cache_read,
+ cache_write_tokens: cache_write,
+ }),
+ }),
+ exec_server_message: None,
+ })
+}
+
+pub(crate) fn end_frame() -> Vec<u8> {
+ encode_connect_frame(b"", 2).to_vec()
+}
+
+fn encode_agent_message(msg: AgentServerMessage) -> Vec<u8> {
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ encode_connect_frame(&payload, 0).to_vec()
+}
diff --git a/src/providers/kimi/translate/request.rs b/src/providers/kimi/translate/request.rs
index f72362c..9c59d7f 100644
--- a/src/providers/kimi/translate/request.rs
+++ b/src/providers/kimi/translate/request.rs
@@ -3,6 +3,10 @@ use serde_json::Value;
use super::model_allowlist::{KIMI_DEFAULT_MODEL, assert_allowed_model, resolve_model};
use crate::anthropic::schema::MessagesRequest;
+use crate::providers::translate_shared::{
+ ContentBlock, flatten_system_text, image_block_to_url, image_source_to_url, normalize_content,
+ read_effort,
+};
// ---------------------------------------------------------------------------
// Kimi OpenAI-compatible chat-completions types
@@ -118,40 +122,6 @@ pub struct TranslateOptions {
const DEFAULT_MAX_TOKENS: u32 = 32000;
-// ---------------------------------------------------------------------------
-// Content block types (parsed from serde_json::Value)
-// ---------------------------------------------------------------------------
-
-#[derive(Debug)]
-pub enum ContentBlock {
- Text {
- text: String,
- },
- Image {
- source: ImageSource,
- },
- ToolUse {
- id: String,
- name: String,
- input: Value,
- },
- ToolResult {
- tool_use_id: String,
- content: Value,
- is_error: Option<bool>,
- },
- Thinking {
- thinking: String,
- },
-}
-
-#[derive(Debug)]
-pub struct ImageSource {
- pub media_type: String,
- pub data: String,
- pub source_type: String,
-}
-
// ---------------------------------------------------------------------------
// Translation entry point
// ---------------------------------------------------------------------------
@@ -208,24 +178,6 @@ fn map_reasoning_effort(effort: Option<&str>) -> String {
}
}
-fn read_effort(req: &MessagesRequest) -> Result<Option<&str>, anyhow::Error> {
- let output_config = match req.extra.get("output_config") {
- Some(Value::Object(m)) => m,
- _ => return Ok(None),
- };
- match output_config.get("effort") {
- Some(Value::String(s)) => {
- let valid = ["low", "medium", "high", "max"];
- if valid.contains(&s.as_str()) {
- Ok(Some(s.as_str()))
- } else {
- anyhow::bail!("Invalid output_config.effort: {s}")
- }
- }
- _ => Ok(None),
- }
-}
-
// ---------------------------------------------------------------------------
// Tool & tool_choice reading
// ---------------------------------------------------------------------------
@@ -299,34 +251,6 @@ fn read_tools(req: &MessagesRequest) -> Result<Vec<KimiTool>, anyhow::Error> {
Ok(out)
}
-// ---------------------------------------------------------------------------
-// System text extraction
-// ---------------------------------------------------------------------------
-
-fn flatten_system_text(system_val: Option<&Value>) -> Option<String> {
- let system = system_val?;
- let texts: Vec<String> = match system {
- Value::String(s) => vec![s.clone()],
- Value::Array(arr) => arr
- .iter()
- .filter_map(|b| {
- let text = b.get("text").and_then(|v| v.as_str())?;
- if text.starts_with("x-anthropic-billing-header:") {
- None
- } else {
- Some(text.to_string())
- }
- })
- .collect(),
- _ => return None,
- };
- if texts.is_empty() {
- None
- } else {
- Some(texts.join("\n\n"))
- }
-}
-
// ---------------------------------------------------------------------------
// Message building
// ---------------------------------------------------------------------------
@@ -344,7 +268,7 @@ fn build_messages(req: &MessagesRequest) -> Result<Vec<KimiMessage>, anyhow::Err
// Convert each message
for msg in &req.messages {
- let blocks = normalize_content(&msg.content);
+ let blocks = normalize_content(&msg.content, serde_json::json!({}));
match msg.role.as_str() {
"user" => push_user_messages(&mut out, &blocks),
"assistant" => push_assistant_message(&mut out, &blocks),
@@ -396,13 +320,10 @@ fn push_user_messages(out: &mut Vec<KimiMessage>, blocks: &[ContentBlock]) {
buffer.push(KimiUserContentPart::Text { text: text.clone() });
}
ContentBlock::Image { source } => {
- let url = if source.source_type == "url" {
- source.data.clone()
- } else {
- format!("data:{};base64,{}", source.media_type, source.data)
- };
buffer.push(KimiUserContentPart::ImageUrl {
- image_url: KimiImageUrl { url },
+ image_url: KimiImageUrl {
+ url: image_source_to_url(source),
+ },
});
}
ContentBlock::ToolResult {
@@ -500,34 +421,6 @@ enum KimiToolResultPart {
ImageUrl { image_url: KimiImageUrl },
}
-fn image_block_to_url(block: &Value) -> String {
- let source_type = block
- .get("source")
- .and_then(|s| s.get("type"))
- .and_then(|v| v.as_str())
- .unwrap_or("base64");
- if source_type == "url" {
- block
- .get("source")
- .and_then(|s| s.get("url"))
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string()
- } else {
- let media_type = block
- .get("source")
- .and_then(|s| s.get("media_type"))
- .and_then(|v| v.as_str())
- .unwrap_or("image/png");
- let data = block
- .get("source")
- .and_then(|s| s.get("data"))
- .and_then(|v| v.as_str())
- .unwrap_or("");
- format!("data:{media_type};base64,{data}")
- }
-}
-
fn push_assistant_message(out: &mut Vec<KimiMessage>, blocks: &[ContentBlock]) {
let mut text_parts: Vec<String> = Vec::new();
let mut thinking_parts: Vec<String> = Vec::new();
@@ -591,108 +484,6 @@ fn push_assistant_message(out: &mut Vec<KimiMessage>, blocks: &[ContentBlock]) {
});
}
-// ---------------------------------------------------------------------------
-// Content normalization (parse serde_json::Value to typed ContentBlocks)
-// ---------------------------------------------------------------------------
-
-fn normalize_content(content: &Value) -> Vec<ContentBlock> {
- match content {
- Value::String(s) => {
- vec![ContentBlock::Text { text: s.clone() }]
- }
- Value::Array(arr) => {
- let mut blocks = Vec::new();
- for item in arr {
- if let Some(block) = parse_content_block(item) {
- blocks.push(block);
- }
- }
- blocks
- }
- _ => Vec::new(),
- }
-}
-
-fn parse_content_block(value: &Value) -> Option<ContentBlock> {
- let kind = value.get("type").and_then(|v| v.as_str())?;
- match kind {
- "text" => {
- let text = value
- .get("text")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- Some(ContentBlock::Text { text })
- }
- "image" => {
- let source = value.get("source")?;
- let media_type = source
- .get("media_type")
- .and_then(|v| v.as_str())
- .unwrap_or("image/png")
- .to_string();
- let source_type = source
- .get("type")
- .and_then(|v| v.as_str())
- .unwrap_or("base64")
- .to_string();
- let data = if source_type == "url" {
- source.get("url").and_then(|v| v.as_str()).unwrap_or("")
- } else {
- source.get("data").and_then(|v| v.as_str()).unwrap_or("")
- }
- .to_string();
- Some(ContentBlock::Image {
- source: ImageSource {
- media_type,
- data,
- source_type,
- },
- })
- }
- "tool_use" => {
- let id = value
- .get("id")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- let name = value
- .get("name")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- let input = value.get("input").cloned().unwrap_or(serde_json::json!({}));
- Some(ContentBlock::ToolUse { id, name, input })
- }
- "tool_result" => {
- let tool_use_id = value
- .get("tool_use_id")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- let content = value
- .get("content")
- .cloned()
- .unwrap_or(Value::String(String::new()));
- let is_error = value.get("is_error").and_then(|v| v.as_bool());
- Some(ContentBlock::ToolResult {
- tool_use_id,
- content,
- is_error,
- })
- }
- "thinking" => {
- let thinking = value
- .get("thinking")
- .and_then(|v| v.as_str())
- .unwrap_or("")
- .to_string();
- Some(ContentBlock::Thinking { thinking })
- }
- _ => None,
- }
-}
-
// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------
diff --git a/src/providers/mod.rs b/src/providers/mod.rs
index c413d22..d539db4 100644
--- a/src/providers/mod.rs
+++ b/src/providers/mod.rs
@@ -1,3 +1,4 @@
pub mod codex;
pub mod cursor;
pub mod kimi;
+pub mod translate_shared;
diff --git a/src/providers/translate_shared.rs b/src/providers/translate_shared.rs
new file mode 100644
index 0000000..0e7bbdc
--- /dev/null
+++ b/src/providers/translate_shared.rs
@@ -0,0 +1,209 @@
+use serde_json::Value;
+
+use crate::anthropic::schema::MessagesRequest;
+
+#[derive(Debug)]
+pub enum ContentBlock {
+ Text {
+ text: String,
+ },
+ Image {
+ source: ImageSource,
+ },
+ ToolUse {
+ id: String,
+ name: String,
+ input: Value,
+ },
+ ToolResult {
+ tool_use_id: String,
+ content: Value,
+ is_error: Option<bool>,
+ },
+ Thinking {
+ thinking: String,
+ },
+}
+
+#[derive(Debug)]
+pub struct ImageSource {
+ pub media_type: String,
+ pub data: String,
+ pub source_type: String,
+}
+
+pub fn flatten_system_text(system_val: Option<&Value>) -> Option<String> {
+ let system = system_val?;
+ let texts: Vec<String> = match system {
+ Value::String(s) => vec![s.clone()],
+ Value::Array(arr) => arr
+ .iter()
+ .filter_map(|b| {
+ let text = b.get("text").and_then(|v| v.as_str())?;
+ if text.starts_with("x-anthropic-billing-header:") {
+ None
+ } else {
+ Some(text.to_string())
+ }
+ })
+ .collect(),
+ _ => return None,
+ };
+ if texts.is_empty() {
+ None
+ } else {
+ Some(texts.join("\n\n"))
+ }
+}
+
+pub fn read_effort(req: &MessagesRequest) -> Result<Option<&str>, anyhow::Error> {
+ let output_config = match req.extra.get("output_config") {
+ Some(Value::Object(m)) => m,
+ _ => return Ok(None),
+ };
+ match output_config.get("effort") {
+ Some(Value::String(s)) => {
+ let valid = ["low", "medium", "high", "max"];
+ if valid.contains(&s.as_str()) {
+ Ok(Some(s.as_str()))
+ } else {
+ anyhow::bail!("Invalid output_config.effort: {s}")
+ }
+ }
+ _ => Ok(None),
+ }
+}
+
+pub fn normalize_content(content: &Value, missing_tool_input: Value) -> Vec<ContentBlock> {
+ match content {
+ Value::String(s) => {
+ vec![ContentBlock::Text { text: s.clone() }]
+ }
+ Value::Array(arr) => {
+ let mut blocks = Vec::new();
+ for item in arr {
+ if let Some(block) = parse_content_block(item, missing_tool_input.clone()) {
+ blocks.push(block);
+ }
+ }
+ blocks
+ }
+ _ => Vec::new(),
+ }
+}
+
+pub fn image_source_to_url(source: &ImageSource) -> String {
+ if source.source_type == "url" {
+ source.data.clone()
+ } else {
+ format!("data:{};base64,{}", source.media_type, source.data)
+ }
+}
+
+pub fn image_block_to_url(block: &Value) -> String {
+ let source_type = block
+ .get("source")
+ .and_then(|s| s.get("type"))
+ .and_then(|v| v.as_str())
+ .unwrap_or("base64");
+ if source_type == "url" {
+ block
+ .get("source")
+ .and_then(|s| s.get("url"))
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string()
+ } else {
+ let media_type = block
+ .get("source")
+ .and_then(|s| s.get("media_type"))
+ .and_then(|v| v.as_str())
+ .unwrap_or("image/png");
+ let data = block
+ .get("source")
+ .and_then(|s| s.get("data"))
+ .and_then(|v| v.as_str())
+ .unwrap_or("");
+ format!("data:{media_type};base64,{data}")
+ }
+}
+
+fn parse_content_block(value: &Value, missing_tool_input: Value) -> Option<ContentBlock> {
+ let kind = value.get("type").and_then(|v| v.as_str())?;
+ match kind {
+ "text" => {
+ let text = value
+ .get("text")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string();
+ Some(ContentBlock::Text { text })
+ }
+ "image" => {
+ let source = value.get("source")?;
+ let media_type = source
+ .get("media_type")
+ .and_then(|v| v.as_str())
+ .unwrap_or("image/png")
+ .to_string();
+ let source_type = source
+ .get("type")
+ .and_then(|v| v.as_str())
+ .unwrap_or("base64")
+ .to_string();
+ let data = if source_type == "url" {
+ source.get("url").and_then(|v| v.as_str()).unwrap_or("")
+ } else {
+ source.get("data").and_then(|v| v.as_str()).unwrap_or("")
+ }
+ .to_string();
+ Some(ContentBlock::Image {
+ source: ImageSource {
+ media_type,
+ data,
+ source_type,
+ },
+ })
+ }
+ "tool_use" => {
+ let id = value
+ .get("id")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string();
+ let name = value
+ .get("name")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string();
+ let input = value.get("input").cloned().unwrap_or(missing_tool_input);
+ Some(ContentBlock::ToolUse { id, name, input })
+ }
+ "tool_result" => {
+ let tool_use_id = value
+ .get("tool_use_id")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string();
+ let content = value
+ .get("content")
+ .cloned()
+ .unwrap_or(Value::String(String::new()));
+ let is_error = value.get("is_error").and_then(|v| v.as_bool());
+ Some(ContentBlock::ToolResult {
+ tool_use_id,
+ content,
+ is_error,
+ })
+ }
+ "thinking" => {
+ let thinking = value
+ .get("thinking")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string();
+ Some(ContentBlock::Thinking { thinking })
+ }
+ _ => None,
+ }
+}