///|
/// Convert OpenAI API responses back to Claude API format.
///|
pub fn convert_openai_to_claude_response(
openai_response : Map[String, Json],
original_model : String,
) -> Map[String, Json] {
let choices = match openai_response.get("choices") {
Some(Json::Array(arr)) => arr
_ => abort("No choices in OpenAI response")
}
let (content_blocks, finish_reason) = if choices.length() > 0 {
extract_content_and_finish(choices[0])
} else {
(
[Json::object({ "type": Json::string("text"), "text": Json::string("") })],
"stop",
)
}
let stop_reason = match finish_reason {
"stop" => "end_turn"
"length" => "max_tokens"
"tool_calls" => "tool_use"
"function_call" => "tool_use"
_ => "end_turn"
}
let message_id = match openai_response.get("id") {
Some(Json::String(id)) => id
_ => "msg_000000000000000000000000"
}
let usage_input = match openai_response.get("usage") {
Some(Json::Object(usage)) =>
match usage.get("prompt_tokens") {
Some(Json::Number(n)) => n.to_int()
_ => 0
}
_ => 0
}
let usage_output = match openai_response.get("usage") {
Some(Json::Object(usage)) =>
match usage.get("completion_tokens") {
Some(Json::Number(n)) => n.to_int()
_ => 0
}
_ => 0
}
let result : Map[String, Json] = {}
result["id"] = Json::string(message_id)
result["type"] = Json::string("message")
result["role"] = Json::string("assistant")
result["model"] = Json::string(original_model)
result["content"] = Json::array(content_blocks)
result["stop_reason"] = Json::string(stop_reason)
result["stop_sequence"] = Json::null()
result["usage"] = Json::object({
"input_tokens": Json::number(usage_input.to_double()),
"output_tokens": Json::number(usage_output.to_double()),
})
result
}
///|
fn extract_content_and_finish(choice : Json) -> (Array[Json], String) {
let content_blocks : Array[Json] = []
let mut finish_reason = "stop"
match choice {
Json::Object(obj) => {
finish_reason = match obj.get("finish_reason") {
Some(Json::String(s)) => s
_ => "stop"
}
match obj.get("message") {
Some(Json::Object(message)) => {
match message.get("content") {
Some(Json::String(text)) if text != "" =>
content_blocks.push(
Json::object({
"type": Json::string("text"),
"text": Json::string(text),
}),
)
_ => ()
}
match message.get("tool_calls") {
Some(Json::Array(tool_calls)) =>
for tc in tool_calls {
match tc {
Json::Object(tc_obj) =>
match tc_obj.get("function") {
Some(Json::Object(fn_obj)) => {
let fn_name = match fn_obj.get("name") {
Some(Json::String(n)) => n
_ => ""
}
let fn_args = match fn_obj.get("arguments") {
Some(Json::String(args)) =>
@json.parse(args) catch {
_ => Json::object({})
}
_ => Json::object({})
}
let tc_id = match tc_obj.get("id") {
Some(Json::String(id)) => id
_ => "tool_00000000"
}
content_blocks.push(
Json::object({
"type": Json::string("tool_use"),
"id": Json::string(tc_id),
"name": Json::string(fn_name),
"input": fn_args,
}),
)
}
_ => ()
}
_ => ()
}
}
_ => ()
}
}
_ => ()
}
}
_ => ()
}
if content_blocks.length() == 0 {
content_blocks.push(
Json::object({ "type": Json::string("text"), "text": Json::string("") }),
)
}
(content_blocks, finish_reason)
}
///|
pub fn sse_message_start(message_id : String, model : String) -> String {
let data = Json::object({
"type": Json::string("message_start"),
"message": Json::object({
"id": Json::string(message_id),
"type": Json::string("message"),
"role": Json::string("assistant"),
"model": Json::string(model),
"content": Json::array([]),
"stop_reason": Json::null(),
"stop_sequence": Json::null(),
"usage": Json::object({
"input_tokens": Json::number(0.0),
"output_tokens": Json::number(0.0),
}),
}),
})
"event: message_start\ndata: \{data.stringify()}\n\n"
}
///|
pub fn sse_content_block_start(index : Int) -> String {
let data = Json::object({
"type": Json::string("content_block_start"),
"index": Json::number(index.to_double()),
"content_block": Json::object({
"type": Json::string("text"),
"text": Json::string(""),
}),
})
"event: content_block_start\ndata: \{data.stringify()}\n\n"
}
///|
pub fn sse_ping() -> String {
let data = Json::object({ "type": Json::string("ping") })
"event: ping\ndata: \{data.stringify()}\n\n"
}
///|
pub fn sse_text_delta(index : Int, text : String) -> String {
let data = Json::object({
"type": Json::string("content_block_delta"),
"index": Json::number(index.to_double()),
"delta": Json::object({
"type": Json::string("text_delta"),
"text": Json::string(text),
}),
})
"event: content_block_delta\ndata: \{data.stringify()}\n\n"
}
///|
pub fn sse_content_block_stop(index : Int) -> String {
let data = Json::object({
"type": Json::string("content_block_stop"),
"index": Json::number(index.to_double()),
})
"event: content_block_stop\ndata: \{data.stringify()}\n\n"
}
///|
pub fn sse_message_delta(
stop_reason : String,
input_tokens : Int,
output_tokens : Int,
) -> String {
let data = Json::object({
"type": Json::string("message_delta"),
"delta": Json::object({
"stop_reason": Json::string(stop_reason),
"stop_sequence": Json::null(),
}),
"usage": Json::object({
"input_tokens": Json::number(input_tokens.to_double()),
"output_tokens": Json::number(output_tokens.to_double()),
}),
})
"event: message_delta\ndata: \{data.stringify()}\n\n"
}
///|
pub fn sse_message_stop() -> String {
let data = Json::object({ "type": Json::string("message_stop") })
"event: message_stop\ndata: \{data.stringify()}\n\n"
}
///|
pub fn sse_error(message : String) -> String {
let data = Json::object({
"type": Json::string("error"),
"error": Json::object({
"type": Json::string("api_error"),
"message": Json::string(message),
}),
})
"event: error\ndata: \{data.stringify()}\n\n"
}