use crate::models::types::{
ChatContentBlock, ChatRequest, ChatResponse, ChatUsage, ModelCapabilities, StreamEvent,
THINKING_HIGH, THINKING_MAX, THINKING_OFF,
};
use crate::models::wire_anthropic::{AnthropicContentBlock, AnthropicResponse, AnthropicUsage};
use crate::models::wire_openai::{OpenAIChatResponse, OpenAIStreamChunk};
use crate::shared::errors::{Error, Result};
use serde_json::{json, Map, Value};
pub fn build_request_body(_caps: &ModelCapabilities, req: &ChatRequest) -> Map<String, Value> {
let mut body: Map<String, Value> = Map::new();
if let Some(raw) = &req.raw_messages {
body.insert("messages".to_string(), raw.clone());
} else if req
.messages
.as_ref()
.map(|m| !m.is_empty())
.unwrap_or(false)
{
body.insert(
"messages".to_string(),
serde_json::to_value(req.messages.as_ref().unwrap()).unwrap_or(Value::Null),
);
}
body.insert("stream".to_string(), Value::Bool(req.stream == Some(true)));
if let Some(mt) = req.max_tokens {
if mt > 0 {
body.insert("max_tokens".to_string(), Value::from(mt));
}
}
if let Some(system) = &req.system {
body.insert("system".to_string(), system.clone());
}
if let Some(temp) = req.temperature {
body.insert("temperature".to_string(), json!(temp));
}
if let Some(tools) = &req.tools {
body.insert("tools".to_string(), tools.clone());
}
let eff = resolve_openai_reasoning_effort(req);
if !eff.is_empty() {
body.insert("reasoning_effort".to_string(), Value::String(eff));
}
if let Some(speed) = &req.speed {
if !speed.is_empty() {
body.insert("speed".to_string(), Value::String(speed.clone()));
}
}
if let Some(rf) = resolve_openai_response_format(req) {
body.insert("response_format".to_string(), Value::Object(rf));
}
if let Some(m) = &req.metadata {
body.insert(
"metadata".to_string(),
serde_json::to_value(m).unwrap_or(Value::Null),
);
}
if let Some(ptc) = req.parallel_tool_calls {
body.insert("parallel_tool_calls".to_string(), Value::Bool(ptc));
}
if let Some(extra) = &req.extra_body {
for (k, v) in extra {
body.insert(k.clone(), v.clone());
}
}
if let Some(uid) = &req.end_user_id {
if !uid.is_empty() {
body.insert("user_id".to_string(), Value::String(uid.clone()));
}
}
if req.stream == Some(true) {
body.insert(
"stream_options".to_string(),
json!({ "include_usage": true }),
);
}
body
}
pub fn parse_response(body_input: &[u8]) -> Result<ChatResponse> {
let raw = unwrap_api_response(body_input)?;
let oai: OpenAIChatResponse = serde_json::from_str(&raw)
.map_err(|e| Error::other(format!("decode openai response: {e}")))?;
Ok(convert_openai_to_chat_response(&oai))
}
pub fn parse_stream_line(event_type: &str, data: &str) -> Result<(StreamEvent, bool)> {
if data == "[DONE]" {
return Ok((StreamEvent::default(), true));
}
serde_json::from_str::<Value>(data)
.map_err(|e| Error::other(format!("parse openai stream chunk: {e}")))?;
Ok((
StreamEvent {
event: event_type.to_string(),
data: data.to_string(),
..Default::default()
},
false,
))
}
pub fn resolve_openai_reasoning_effort(req: &ChatRequest) -> String {
if let Some(effort) = &req.effort {
if !effort.level.is_empty() {
match effort.level.as_str() {
"low" | "medium" | "high" => return effort.level.clone(),
"max" => return "high".to_string(),
_ => {}
}
}
}
if let Some(thinking) = &req.thinking {
match thinking.level.as_deref() {
Some(THINKING_HIGH) => return "high".to_string(),
Some(THINKING_MAX) => return "high".to_string(),
Some(THINKING_OFF) => return String::new(),
_ => {}
}
}
String::new()
}
pub fn resolve_openai_response_format(req: &ChatRequest) -> Option<Map<String, Value>> {
let oc = req.output_config.as_ref()?;
match oc.format.as_deref() {
Some("json_schema") => {
let mut js: Map<String, Value> = Map::new();
if let Some(schema) = &oc.schema {
js.insert("schema".to_string(), schema.clone());
}
js.insert("strict".to_string(), Value::Bool(true));
let mut out: Map<String, Value> = Map::new();
out.insert("type".to_string(), Value::String("json_schema".to_string()));
out.insert("json_schema".to_string(), Value::Object(js));
Some(out)
}
Some("json_object") => {
let mut out: Map<String, Value> = Map::new();
out.insert("type".to_string(), Value::String("json_object".to_string()));
Some(out)
}
Some("") | None => None,
Some(other) => {
let mut out: Map<String, Value> = Map::new();
out.insert("type".to_string(), Value::String(other.to_string()));
Some(out)
}
}
}
fn unwrap_api_response(body_input: &[u8]) -> Result<String> {
let body_str = String::from_utf8_lossy(body_input);
match serde_json::from_str::<Value>(&body_str) {
Ok(wrapper) => {
if let Some(data) = wrapper.get("data").filter(|v| !v.is_null()) {
let code = wrapper.get("code").and_then(|v| v.as_i64()).unwrap_or(0);
if code != 0 {
let message = wrapper
.get("message")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string();
return Err(Error::business(code, message));
}
Ok(data.to_string())
} else {
Ok(body_str.to_string())
}
}
Err(_) => Ok(body_str.to_string()),
}
}
fn convert_openai_to_chat_response(oai: &OpenAIChatResponse) -> ChatResponse {
let mut resp = ChatResponse {
id: oai.id.clone(),
r#type: "message".to_string(),
model: oai.model.clone(),
role: "assistant".to_string(),
content: Vec::new(),
stop_reason: String::new(),
usage: ChatUsage {
input_tokens: oai.usage.prompt_tokens,
output_tokens: oai.usage.completion_tokens,
..Default::default()
},
token_remaining: -1,
call_remaining: -1,
model_token_remaining: -1,
model_token_remaining_etu: -1,
};
if let Some(choice) = oai.choices.first() {
resp.stop_reason = map_finish_reason(&choice.finish_reason);
if let Some(rc) = &choice.message.reasoning_content {
if !rc.is_empty() {
resp.content.push(ChatContentBlock {
r#type: "thinking".to_string(),
thinking: Some(rc.clone()),
..Default::default()
});
}
}
if !choice.message.content.is_empty() {
resp.content.push(ChatContentBlock {
r#type: "text".to_string(),
text: Some(choice.message.content.clone()),
..Default::default()
});
}
if let Some(tcs) = &choice.message.tool_calls {
for tc in tcs {
resp.content.push(ChatContentBlock {
r#type: "tool_use".to_string(),
id: Some(tc.id.clone()),
name: Some(tc.function.name.clone()),
input: Some(try_parse_json(&tc.function.arguments)),
..Default::default()
});
}
}
}
resp
}
fn map_finish_reason(finish_reason: &str) -> String {
match finish_reason {
"stop" => "end_turn".to_string(),
"tool_calls" => "tool_use".to_string(),
"length" => "max_tokens".to_string(),
other => other.to_string(),
}
}
fn try_parse_json(s: &str) -> Value {
serde_json::from_str::<Value>(s).unwrap_or_else(|_| Value::String(s.to_string()))
}
pub fn parse_openai_response_to_anthropic(raw: &[u8]) -> Result<AnthropicResponse> {
let data = unwrap_api_response(raw)?;
let oai: OpenAIChatResponse = serde_json::from_str(&data)
.map_err(|e| Error::other(format!("decode openai response: {e}")))?;
let mut resp = AnthropicResponse {
id: oai.id.clone(),
r#type: "message".to_string(),
role: "assistant".to_string(),
content: Vec::new(),
model: oai.model.clone(),
stop_reason: String::new(),
stop_sequence: None,
usage: AnthropicUsage {
input_tokens: oai.usage.prompt_tokens,
output_tokens: oai.usage.completion_tokens,
..Default::default()
},
};
if let Some(choice) = oai.choices.first() {
resp.stop_reason = map_finish_reason(&choice.finish_reason);
if let Some(rc) = &choice.message.reasoning_content {
if !rc.is_empty() {
resp.content.push(AnthropicContentBlock {
r#type: "thinking".to_string(),
thinking: Some(rc.clone()),
..Default::default()
});
}
}
if !choice.message.content.is_empty() {
resp.content.push(AnthropicContentBlock {
r#type: "text".to_string(),
text: Some(choice.message.content.clone()),
..Default::default()
});
}
if let Some(tcs) = &choice.message.tool_calls {
for tc in tcs {
resp.content.push(AnthropicContentBlock {
r#type: "tool_use".to_string(),
id: Some(tc.id.clone()),
name: Some(tc.function.name.clone()),
input: Some(try_parse_json(&tc.function.arguments)),
..Default::default()
});
}
}
}
Ok(resp)
}
#[derive(Debug, Default)]
pub struct OpenAIStreamConverter {
message_started: bool,
thinking_started: bool,
thinking_stopped: bool,
thinking_block_index: i64,
text_started: bool,
tool_block_index: Vec<(i64, i64)>,
block_index: i64,
}
impl OpenAIStreamConverter {
pub fn new() -> Self {
Self::default()
}
pub fn convert(&mut self, data: &str) -> Result<(Vec<StreamEvent>, bool)> {
if data == "[DONE]" {
return Ok((Vec::new(), true));
}
let chunk: OpenAIStreamChunk = serde_json::from_str(data)
.map_err(|e| Error::other(format!("parse openai stream chunk: {e}")))?;
let mut events: Vec<StreamEvent> = Vec::new();
let choice = match chunk.choices.first() {
Some(c) => c,
None => return Ok((events, false)),
};
if !self.message_started {
self.message_started = true;
let msg_json = json!({
"type": "message_start",
"message": {
"id": chunk.id,
"type": "message",
"role": "assistant",
"content": [],
"model": "",
},
})
.to_string();
events.push(ev("message_start", msg_json));
}
if let Some(rc) = choice.delta.reasoning_content.as_deref() {
if !rc.is_empty() {
if !self.thinking_started {
self.thinking_started = true;
self.thinking_block_index = self.block_index; let block_json = json!({
"type": "content_block_start",
"index": self.block_index,
"content_block": { "type": "thinking", "thinking": "" },
})
.to_string();
events.push(ev("content_block_start", block_json));
}
let delta_json = json!({
"type": "content_block_delta",
"index": self.thinking_block_index,
"delta": { "type": "thinking_delta", "thinking": rc },
})
.to_string();
events.push(ev("content_block_delta", delta_json));
}
}
if let Some(content) = choice.delta.content.as_deref() {
if !content.is_empty() {
if self.thinking_started && !self.thinking_stopped {
self.thinking_stopped = true;
let stop_json = json!({
"type": "content_block_stop",
"index": self.thinking_block_index,
})
.to_string();
events.push(ev("content_block_stop", stop_json));
self.block_index += 1;
}
if !self.text_started {
self.text_started = true;
let block_json = json!({
"type": "content_block_start",
"index": self.block_index,
"content_block": { "type": "text", "text": "" },
})
.to_string();
events.push(ev("content_block_start", block_json));
}
let delta_json = json!({
"type": "content_block_delta",
"index": self.block_index,
"delta": { "type": "text_delta", "text": content },
})
.to_string();
events.push(ev("content_block_delta", delta_json));
}
}
if let Some(tcs) = &choice.delta.tool_calls {
for tc in tcs {
if !self.tool_block_index.iter().any(|(k, _)| *k == tc.index) {
if self.thinking_started && !self.thinking_stopped {
self.thinking_stopped = true;
let stop_json = json!({
"type": "content_block_stop",
"index": self.thinking_block_index,
})
.to_string();
events.push(ev("content_block_stop", stop_json));
self.block_index += 1;
}
if self.text_started {
let stop_json = json!({
"type": "content_block_stop",
"index": self.block_index,
})
.to_string();
events.push(ev("content_block_stop", stop_json));
self.block_index += 1;
self.text_started = false;
}
self.tool_block_index.push((tc.index, self.block_index));
let block_json = json!({
"type": "content_block_start",
"index": self.block_index,
"content_block": {
"type": "tool_use",
"id": tc.id.clone().unwrap_or_default(),
"name": tc.function.name,
"input": {},
},
})
.to_string();
events.push(ev("content_block_start", block_json));
self.block_index += 1; }
if !tc.function.arguments.is_empty() {
let idx = self
.tool_block_index
.iter()
.find(|(k, _)| *k == tc.index)
.map(|(_, v)| *v)
.unwrap();
let delta_json = json!({
"type": "content_block_delta",
"index": idx,
"delta": {
"type": "input_json_delta",
"partial_json": tc.function.arguments,
},
})
.to_string();
events.push(ev("content_block_delta", delta_json));
}
}
}
let finish = choice.finish_reason.as_deref().unwrap_or("");
if !finish.is_empty() {
if self.text_started {
let stop_json = json!({
"type": "content_block_stop",
"index": self.block_index,
})
.to_string();
events.push(ev("content_block_stop", stop_json));
} else if self.thinking_started && !self.thinking_stopped {
self.thinking_stopped = true;
let stop_json = json!({
"type": "content_block_stop",
"index": self.thinking_block_index,
})
.to_string();
events.push(ev("content_block_stop", stop_json));
}
for (_, idx) in &self.tool_block_index {
let stop_json = json!({
"type": "content_block_stop",
"index": idx,
})
.to_string();
events.push(ev("content_block_stop", stop_json));
}
let stop_reason = match finish {
"tool_calls" => "tool_use",
"length" => "max_tokens",
_ => "end_turn",
};
let delta_json = json!({
"type": "message_delta",
"delta": { "stop_reason": stop_reason },
})
.to_string();
events.push(ev("message_delta", delta_json));
let stop_json = json!({ "type": "message_stop" }).to_string();
events.push(ev("message_stop", stop_json));
}
Ok((events, false))
}
}
pub fn new_openai_stream_converter() -> OpenAIStreamConverter {
OpenAIStreamConverter::new()
}
fn ev(event: &str, data: String) -> StreamEvent {
StreamEvent {
event: event.to_string(),
data,
..Default::default()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::types::{ChatMessage, EffortConfig};
use serde_json::json;
fn caps() -> ModelCapabilities {
ModelCapabilities::default()
}
#[test]
fn build_request_body_openai_wire_fields() {
let req = ChatRequest {
messages: Some(vec![ChatMessage {
role: "user".to_string(),
content: "hi".to_string(),
}]),
stream: Some(true),
max_tokens: Some(64),
parallel_tool_calls: Some(false),
end_user_id: Some("u-9".to_string()),
effort: Some(EffortConfig {
level: "high".to_string(),
}),
..Default::default()
};
let body = build_request_body(&caps(), &req);
assert_eq!(body["parallel_tool_calls"], json!(false));
assert_eq!(body["user_id"], json!("u-9"));
assert_eq!(body["reasoning_effort"], json!("high"));
assert_eq!(body["stream_options"], json!({"include_usage": true}));
assert!(body.get("betas").is_none());
}
#[test]
fn end_user_id_wins_over_extra_body_user_id() {
let mut extra = serde_json::Map::new();
extra.insert("user_id".to_string(), json!("from-extra"));
let req = ChatRequest {
extra_body: Some(extra),
end_user_id: Some("explicit".to_string()),
..Default::default()
};
let body = build_request_body(&caps(), &req);
assert_eq!(body["user_id"], json!("explicit"));
}
#[test]
fn parse_stream_line_done_and_invalid() {
let (_, done) = parse_stream_line("", "[DONE]").unwrap();
assert!(done);
let (ev, d) = parse_stream_line("message", "{}").unwrap();
assert!(!d);
assert_eq!(ev.event, "message");
assert!(parse_stream_line("message", "not json").is_err());
}
#[test]
fn convert_openai_to_chat_response_maps_finish_reason() {
let body = br#"{"id":"c1","object":"chat.completion","model":"m","choices":[{"index":0,"message":{"role":"assistant","content":"hello"},"finish_reason":"stop"}],"usage":{"prompt_tokens":3,"completion_tokens":5,"total_tokens":8}}"#;
let resp = parse_response(body).unwrap();
assert_eq!(resp.stop_reason, "end_turn");
assert_eq!(resp.content.len(), 1);
assert_eq!(resp.content[0].r#type, "text");
assert_eq!(resp.usage.input_tokens, 3);
assert_eq!(resp.token_remaining, -1);
}
#[test]
fn stream_converter_emits_message_start_then_done() {
let mut conv = new_openai_stream_converter();
let chunk = r#"{"id":"c","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"hi"},"finish_reason":null}]}"#;
let (events, done) = conv.convert(chunk).unwrap();
assert!(!done);
assert_eq!(events[0].event, "message_start");
assert!(events.iter().any(|e| e.event == "content_block_delta"));
let (_, d) = conv.convert("[DONE]").unwrap();
assert!(d);
}
}