///|
/// HTTP server with API endpoints for the Claude-to-OpenAI proxy.
///|
pub async fn start_server(config : Config) -> Unit {
let addr_str = "\{config.host}:\{config.port.to_string()}"
let addr = @socket.Addr::parse(addr_str)
let server = @http.Server::Server(addr, reuse_addr=true)
println("Claude-to-OpenAI API Proxy v0.1.0 (MoonBit)")
println("OpenAI Base URL: \{config.openai_base_url}")
println("Big Model (opus): \{config.big_model}")
println("Middle Model (sonnet): \{config.middle_model}")
println("Small Model (haiku): \{config.small_model}")
println("Server: \{addr_str}")
let key_validation = if config.anthropic_api_key is Some(_) {
"Enabled"
} else {
"Disabled"
}
println("Client API Key Validation: \{key_validation}")
println("")
server.run_forever(
(request, reader, conn) => handle_request(request, reader, conn, config),
allow_failure=true,
)
}
///|
async fn handle_request(
request : @http.Request,
reader : &@io.Reader,
conn : @http.ServerConnection,
config : Config,
) -> Unit {
let path = request.path
let meth = request.meth
match meth {
Post =>
match path {
"/v1/messages" => handle_messages(request, reader, conn, config)
"/v1/messages/count_tokens" => handle_count_tokens(reader, conn)
_ => not_found(conn)
}
Get =>
match path {
"/health" => handle_health(conn, config)
"/test-connection" => handle_test_connection(conn, config)
"/" => handle_root(conn, config)
_ => not_found(conn)
}
_ => {
conn.send_response(405, "Method Not Allowed")
conn.end_response()
}
}
}
///|
async fn not_found(conn : @http.ServerConnection) -> Unit {
conn.send_response(404, "Not Found")
conn.end_response()
}
///|
async fn handle_messages(
request : @http.Request,
reader : &@io.Reader,
conn : @http.ServerConnection,
config : Config,
) -> Unit {
// Validate API key if configured
match config.anthropic_api_key {
Some(_) => {
let valid = match request.headers.get("x-api-key") {
Some(key) => config.validate_client_api_key(key)
None =>
match request.headers.get("authorization") {
Some(auth) if auth.has_prefix("Bearer ") =>
config.validate_client_api_key(
auth.substring(start=7, end=auth.length()),
)
_ => false
}
}
if !valid {
send_error(conn, 401, "Invalid API key")
return
}
}
None => ()
}
// Read request body
let body_text = try {
let data = reader.read_all()
data.text()
} catch {
_ => {
send_error(conn, 400, "Failed to read request body")
return
}
}
let json_result = try? @json.parse(body_text)
let json = match json_result {
Ok(j) => j
Err(_) => {
send_error(conn, 400, "Invalid JSON body")
return
}
}
let claude_request = match ClaudeMessagesRequest::from_json(json) {
Some(req) => req
None => {
send_error(conn, 400, "Invalid Claude request format")
return
}
}
let openai_request = convert_claude_to_openai(claude_request, config)
let client = OpenAIClient::new(config)
if claude_request.stream {
handle_streaming(conn, client, openai_request, claude_request.model)
} else {
handle_non_streaming(conn, client, openai_request, claude_request.model)
}
}
///|
async fn handle_non_streaming(
conn : @http.ServerConnection,
client : OpenAIClient,
openai_request : Map[String, Json],
original_model : String,
) -> Unit {
let openai_response = client.chat_completion(openai_request)
match openai_response.get("error") {
Some(err) => {
let msg = match err {
Json::String(s) => s
_ => "API error"
}
send_error(conn, 500, msg)
}
None => {
let claude_response = convert_openai_to_claude_response(
openai_response, original_model,
)
let response_json = Json::object(claude_response).stringify()
conn.send_response(200, "OK", extra_headers={
"Content-Type": "application/json",
"Access-Control-Allow-Origin": "*",
})
conn.write(response_json)
conn.end_response()
}
}
}
///|
async fn handle_streaming(
conn : @http.ServerConnection,
client : OpenAIClient,
openai_request : Map[String, Json],
original_model : String,
) -> Unit {
let sse_lines = client.chat_completion_stream(openai_request)
conn.send_response(200, "OK", extra_headers={
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache",
"Connection": "keep-alive",
"Access-Control-Allow-Origin": "*",
})
let message_id = "msg_000000000000000000000000"
conn.write(sse_message_start(message_id, original_model))
conn.write(sse_content_block_start(0))
conn.write(sse_ping())
let mut final_stop_reason = "end_turn"
let mut usage_input = 0
let mut usage_output = 0
for line in sse_lines {
if line.has_prefix("data: ") {
let data_str = line.substring(start=6, end=line.length())
if data_str == "[DONE]" {
break
}
let chunk = @json.parse(data_str) catch { _ => continue }
match chunk {
Json::Object(obj) => {
match obj.get("usage") {
Some(Json::Object(usage)) => {
match usage.get("prompt_tokens") {
Some(Json::Number(n)) => usage_input = n.to_int()
_ => ()
}
match usage.get("completion_tokens") {
Some(Json::Number(n)) => usage_output = n.to_int()
_ => ()
}
}
_ => ()
}
match obj.get("choices") {
Some(Json::Array(choices)) if choices.length() > 0 =>
match choices[0] {
Json::Object(choice) => {
match choice.get("delta") {
Some(Json::Object(delta)) =>
match delta.get("content") {
Some(Json::String(text)) if text != "" =>
conn.write(sse_text_delta(0, text))
_ => ()
}
_ => ()
}
match choice.get("finish_reason") {
Some(Json::String(fr)) if fr != "" =>
final_stop_reason = map_finish_reason(fr)
_ => ()
}
}
_ => ()
}
_ => ()
}
}
_ => continue
}
}
}
conn.write(sse_content_block_stop(0))
conn.write(sse_message_delta(final_stop_reason, usage_input, usage_output))
conn.write(sse_message_stop())
conn.end_response()
}
///|
fn map_finish_reason(fr : String) -> String {
match fr {
"length" => "max_tokens"
"tool_calls" => "tool_use"
"function_call" => "tool_use"
"stop" => "end_turn"
_ => "end_turn"
}
}
///|
async fn handle_count_tokens(
reader : &@io.Reader,
conn : @http.ServerConnection,
) -> Unit {
let body_text = try {
let data = reader.read_all()
data.text()
} catch {
_ => {
send_error(conn, 400, "Failed to read body")
return
}
}
let mut total_chars = 0
let json = @json.parse(body_text) catch {
_ =>
// ignore parse errors
Json::null()
}
match ClaudeTokenCountRequest::from_json(json) {
Some(req) => {
match req.system {
Some(Json::String(s)) => total_chars += s.length()
Some(Json::Array(arr)) =>
for block in arr {
match block {
Json::Object(obj) =>
match obj.get("text") {
Some(Json::String(t)) => total_chars += t.length()
_ => ()
}
_ => ()
}
}
_ => ()
}
for msg in req.messages {
match msg.content {
Json::String(s) => total_chars += s.length()
Json::Array(arr) =>
for block in arr {
match block {
Json::Object(obj) =>
match obj.get("text") {
Some(Json::String(t)) => total_chars += t.length()
_ => ()
}
_ => ()
}
}
_ => ()
}
}
}
None => ()
}
let estimated_tokens = if total_chars < 4 { 1 } else { total_chars / 4 }
let response_str = Json::object({
"input_tokens": Json::number(estimated_tokens.to_double()),
}).stringify()
conn.send_response(200, "OK", extra_headers={
"Content-Type": "application/json",
})
conn.write(response_str)
conn.end_response()
}
///|
async fn handle_health(conn : @http.ServerConnection, config : Config) -> Unit {
let data = Json::object({
"status": Json::string("healthy"),
"openai_api_configured": Json::boolean(true),
"client_api_key_validation": if config.anthropic_api_key is Some(_) {
Json::boolean(true)
} else {
Json::boolean(false)
},
})
conn.send_response(200, "OK", extra_headers={
"Content-Type": "application/json",
})
conn.write(data.stringify())
conn.end_response()
}
///|
async fn handle_test_connection(
conn : @http.ServerConnection,
config : Config,
) -> Unit {
let client = OpenAIClient::new(config)
let request_body : Map[String, Json] = {}
request_body["model"] = Json::string(config.small_model)
request_body["messages"] = Json::array([
Json::object({
"role": Json::string("user"),
"content": Json::string("Hello"),
}),
])
request_body["max_tokens"] = Json::number(5.0)
let openai_response = client.chat_completion(request_body)
match openai_response.get("error") {
Some(_) => {
let data = Json::object({
"status": Json::string("failed"),
"error_type": Json::string("API Error"),
}).stringify()
conn.send_response(503, "Service Unavailable", extra_headers={
"Content-Type": "application/json",
})
conn.write(data)
conn.end_response()
}
None => {
let data = Json::object({
"status": Json::string("success"),
"message": Json::string("Successfully connected to OpenAI API"),
"model_used": Json::string(config.small_model),
}).stringify()
conn.send_response(200, "OK", extra_headers={
"Content-Type": "application/json",
})
conn.write(data)
conn.end_response()
}
}
}
///|
async fn handle_root(conn : @http.ServerConnection, config : Config) -> Unit {
let data = Json::object({
"message": Json::string("Claude-to-OpenAI API Proxy v0.1.0 (MoonBit)"),
"status": Json::string("running"),
"config": Json::object({
"openai_base_url": Json::string(config.openai_base_url),
"max_tokens_limit": Json::number(config.max_tokens_limit.to_double()),
"big_model": Json::string(config.big_model),
"small_model": Json::string(config.small_model),
}),
"endpoints": Json::object({
"messages": Json::string("/v1/messages"),
"count_tokens": Json::string("/v1/messages/count_tokens"),
"health": Json::string("/health"),
"test_connection": Json::string("/test-connection"),
}),
})
conn.send_response(200, "OK", extra_headers={
"Content-Type": "application/json",
"Access-Control-Allow-Origin": "*",
})
conn.write(data.stringify())
conn.end_response()
}
///|
async fn send_error(
conn : @http.ServerConnection,
code : Int,
message : String,
) -> Unit {
let error_str = Json::object({
"type": Json::string("error"),
"error": Json::object({
"type": Json::string("api_error"),
"message": Json::string(message),
}),
}).stringify()
conn.send_response(code, get_reason(code), extra_headers={
"Content-Type": "application/json",
})
conn.write(error_str)
conn.end_response()
}
///|
fn get_reason(code : Int) -> String {
match code {
200 => "OK"
400 => "Bad Request"
401 => "Unauthorized"
404 => "Not Found"
405 => "Method Not Allowed"
500 => "Internal Server Error"
503 => "Service Unavailable"
_ => "Unknown"
}
}