///|
/// Convert Claude API requests to OpenAI API format.
///|
pub fn convert_claude_to_openai(
request : ClaudeMessagesRequest,
config : Config,
) -> Map[String, Json] {
let openai_model = map_claude_model_to_openai(request.model, config)
let openai_messages : Array[Json] = []
// Add system message if present
match request.system {
Some(system) => {
let system_text = extract_system_text(system)
if system_text != "" {
openai_messages.push(
Json::object({
"role": Json::string("system"),
"content": Json::string(system_text),
}),
)
}
}
None => ()
}
// Process messages with tool result merging
let mut i = 0
while i < request.messages.length() {
let msg = request.messages[i]
match msg.role {
"user" => openai_messages.push(convert_user_message(msg))
"assistant" => {
openai_messages.push(convert_assistant_message(msg))
if i + 1 < request.messages.length() {
let next_msg = request.messages[i + 1]
if next_msg.role == "user" && has_tool_results(next_msg.content) {
i += 1
for tr in convert_tool_results(request.messages[i]) {
openai_messages.push(tr)
}
}
}
}
_ => ()
}
i += 1
}
// Calculate max_tokens (clamped)
let max_tokens = if request.max_tokens < config.min_tokens_limit {
config.min_tokens_limit
} else if request.max_tokens > config.max_tokens_limit {
config.max_tokens_limit
} else {
request.max_tokens
}
// Build OpenAI request
let openai_request : Map[String, Json] = {}
openai_request["model"] = Json::string(openai_model)
openai_request["messages"] = Json::array(openai_messages)
openai_request["max_tokens"] = Json::number(max_tokens.to_double())
openai_request["temperature"] = Json::number(request.temperature)
openai_request["stream"] = if request.stream {
Json::boolean(true)
} else {
Json::boolean(false)
}
// Add optional stop sequences
if request.stop_sequences.length() > 0 {
let stop_arr : Array[Json] = []
for s in request.stop_sequences {
stop_arr.push(Json::string(s))
}
openai_request["stop"] = Json::array(stop_arr)
}
// Add optional top_p
match request.top_p {
Some(top_p) => openai_request["top_p"] = Json::number(top_p)
None => ()
}
// Convert tools
if request.tools.length() > 0 {
let openai_tools : Array[Json] = []
for tool in request.tools {
if tool.name != "" {
openai_tools.push(
Json::object({
"type": Json::string("function"),
"function": Json::object({
"name": Json::string(tool.name),
"description": match tool.description {
Some(d) => Json::string(d)
None => Json::string("")
},
"parameters": Json::object(tool.input_schema),
}),
}),
)
}
}
if openai_tools.length() > 0 {
openai_request["tools"] = Json::array(openai_tools)
}
}
// Convert tool choice
match request.tool_choice {
Some(tc) =>
match tc.get("type") {
Some(Json::String(choice_type)) =>
if choice_type == "auto" || choice_type == "any" {
openai_request["tool_choice"] = Json::string("auto")
} else if choice_type == "tool" {
match tc.get("name") {
Some(name) =>
openai_request["tool_choice"] = Json::object({
"type": Json::string("function"),
"function": Json::object({ "name": name }),
})
_ => openai_request["tool_choice"] = Json::string("auto")
}
} else {
openai_request["tool_choice"] = Json::string("auto")
}
_ => ()
}
None => ()
}
openai_request
}
///|
fn extract_system_text(system : Json) -> String {
match system {
Json::String(s) => s
Json::Array(arr) => {
let parts : Array[String] = []
for block in arr {
match block {
Json::Object(obj) =>
match obj.get("type") {
Some(Json::String("text")) =>
match obj.get("text") {
Some(Json::String(t)) => parts.push(t)
_ => ()
}
_ => ()
}
_ => ()
}
}
parts.join("\n\n")
}
_ => ""
}
}
///|
fn has_tool_results(content : Json) -> Bool {
match content {
Json::Array(arr) => {
for item in arr {
match item {
Json::Object(obj) =>
match obj.get("type") {
Some(Json::String("tool_result")) => return true
_ => ()
}
_ => ()
}
}
false
}
_ => false
}
}
///|
fn convert_user_message(msg : ClaudeMessage) -> Json {
match msg.content {
Json::String(s) =>
Json::object({ "role": Json::string("user"), "content": Json::string(s) })
Json::Array(arr) => {
let openai_content : Array[Json] = []
for block in arr {
match block {
Json::Object(obj) =>
match obj.get("type") {
Some(Json::String("text")) =>
match obj.get("text") {
Some(Json::String(t)) =>
openai_content.push(
Json::object({
"type": Json::string("text"),
"text": Json::string(t),
}),
)
_ => ()
}
Some(Json::String("image")) =>
match obj.get("source") {
Some(Json::Object(source)) => {
let media_type = match source.get("media_type") {
Some(Json::String(mt)) => mt
_ => ""
}
let data = match source.get("data") {
Some(Json::String(d)) => d
_ => ""
}
if media_type != "" && data != "" {
openai_content.push(
Json::object({
"type": Json::string("image_url"),
"image_url": Json::object({
"url": Json::string(
"data:\{media_type};base64,\{data}",
),
}),
}),
)
}
}
_ => ()
}
_ => ()
}
_ => ()
}
}
if openai_content.length() == 1 {
match openai_content[0] {
Json::Object(o) if o.get("type") == Some(Json::string("text")) => {
let text = match o.get("text") {
Some(Json::String(t)) => t
_ => ""
}
Json::object({
"role": Json::string("user"),
"content": Json::string(text),
})
}
_ =>
Json::object({
"role": Json::string("user"),
"content": Json::array(openai_content),
})
}
} else {
Json::object({
"role": Json::string("user"),
"content": Json::array(openai_content),
})
}
}
_ =>
Json::object({ "role": Json::string("user"), "content": Json::string("") })
}
}
///|
fn convert_assistant_message(msg : ClaudeMessage) -> Json {
let text_parts : Array[String] = []
let tool_calls : Array[Json] = []
match msg.content {
Json::String(s) =>
Json::object({
"role": Json::string("assistant"),
"content": Json::string(s),
})
Json::Array(arr) => {
for block in arr {
match block {
Json::Object(obj) =>
match obj.get("type") {
Some(Json::String("text")) =>
match obj.get("text") {
Some(Json::String(t)) => text_parts.push(t)
_ => ()
}
Some(Json::String("tool_use")) => {
let id = match obj.get("id") {
Some(Json::String(s)) => s
_ => ""
}
let name = match obj.get("name") {
Some(Json::String(s)) => s
_ => ""
}
let args = match obj.get("input") {
Some(input) => input.stringify()
None => "{}"
}
tool_calls.push(
Json::object({
"id": Json::string(id),
"type": Json::string("function"),
"function": Json::object({
"name": Json::string(name),
"arguments": Json::string(args),
}),
}),
)
}
_ => ()
}
_ => ()
}
}
let content_value : Json = if text_parts.length() > 0 {
Json::string(text_parts.join(""))
} else {
Json::null()
}
if tool_calls.length() > 0 {
Json::object({
"role": Json::string("assistant"),
"content": content_value,
"tool_calls": Json::array(tool_calls),
})
} else {
Json::object({
"role": Json::string("assistant"),
"content": content_value,
})
}
}
_ =>
Json::object({
"role": Json::string("assistant"),
"content": Json::null(),
})
}
}
///|
fn convert_tool_results(msg : ClaudeMessage) -> Array[Json] {
let tool_messages : Array[Json] = []
match msg.content {
Json::Array(arr) =>
for block in arr {
match block {
Json::Object(obj) =>
match obj.get("type") {
Some(Json::String("tool_result")) => {
let tool_use_id = match obj.get("tool_use_id") {
Some(Json::String(s)) => s
_ => ""
}
let content = match obj.get("content") {
Some(c) => parse_tool_result_content(c)
None => "No content provided"
}
tool_messages.push(
Json::object({
"role": Json::string("tool"),
"tool_call_id": Json::string(tool_use_id),
"content": Json::string(content),
}),
)
}
_ => ()
}
_ => ()
}
}
_ => ()
}
tool_messages
}
///|
fn parse_tool_result_content(content : Json) -> String {
match content {
Json::String(s) => s
Json::Array(arr) => {
let parts : Array[String] = []
for item in arr {
match item {
Json::Object(obj) =>
match obj.get("text") {
Some(Json::String(t)) => parts.push(t)
_ => parts.push(item.stringify())
}
Json::String(s) => parts.push(s)
_ => parts.push(item.stringify())
}
}
parts.join("\n")
}
_ => content.stringify()
}
}