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, OpenAIStreamToolCall};
use crate::shared::errors::{Error, Result};
use serde_json::{json, Map, Number, 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_with_max(req, _caps.supports_max_effort);
if !eff.is_empty() {
body.insert("reasoning_effort".to_string(), Value::String(eff));
}
if _caps.supports_thinking
&& req.thinking.as_ref().and_then(|t| t.level.as_deref()) == Some(THINKING_OFF)
{
body.insert("thinking".to_string(), json!({"type":"disabled"}));
}
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 {
resolve_openai_reasoning_effort_with_max(req, false)
}
fn resolve_openai_reasoning_effort_with_max(req: &ChatRequest, supports_max: bool) -> String {
let max_effort = if supports_max { "max" } else { "high" };
if let Some(effort) = &req.effort {
if !effort.level.is_empty() {
match effort.level.as_str() {
"low" | "medium" | "high" | "xhigh" => return effort.level.clone(),
"max" => return max_effort.to_string(),
_ => {}
}
}
}
if let Some(thinking) = &req.thinking {
match thinking.level.as_deref() {
Some("low") => return "low".to_string(),
Some("medium") => return "medium".to_string(),
Some("xhigh") => return "xhigh".to_string(),
Some(THINKING_HIGH) => return "high".to_string(),
Some(THINKING_MAX) => return max_effort.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: 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: tc.function.name.clone(),
input: Some(try_parse_json(&tc.function.arguments)),
..Default::default()
});
}
}
}
Ok(resp)
}
#[derive(Debug)]
struct StreamMessageUsage {
input_tokens: Option<Number>,
output_tokens: Option<Number>,
}
impl StreamMessageUsage {
fn to_json(&self) -> Value {
let mut usage = Map::new();
if let Some(n) = &self.input_tokens {
usage.insert("input_tokens".to_string(), Value::Number(n.clone()));
}
if let Some(n) = &self.output_tokens {
usage.insert("output_tokens".to_string(), Value::Number(n.clone()));
}
Value::Object(usage)
}
}
fn read_stream_usage(raw: Option<&Value>) -> Option<StreamMessageUsage> {
let usage = raw?.as_object()?;
let count = |key: &str| match usage.get(key) {
Some(Value::Number(n)) => Some(n.clone()),
_ => None,
};
Some(StreamMessageUsage {
input_tokens: count("prompt_tokens"),
output_tokens: count("completion_tokens"),
})
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum ToolKey {
Index(i64),
Id(String),
}
#[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<(ToolKey, i64)>,
tool_args_accum: Vec<(ToolKey, String)>,
last_tool_key: Option<ToolKey>,
block_index: i64,
message_closed: bool,
blocks_closed: bool,
pending_stop_reason: Option<String>,
usage: Option<StreamMessageUsage>,
}
impl OpenAIStreamConverter {
pub fn new() -> Self {
Self::default()
}
fn resolve_tool_key(&mut self, tc: &OpenAIStreamToolCall) -> ToolKey {
if let Some(index) = tc.index {
let key = ToolKey::Index(index);
self.last_tool_key = Some(key.clone());
return key;
}
if let Some(id) = tc.id.as_deref().filter(|id| !id.is_empty()) {
let key = ToolKey::Id(id.to_string());
self.last_tool_key = Some(key.clone());
return key;
}
if let Some(key) = &self.last_tool_key {
return key.clone();
}
let key = ToolKey::Index(0);
self.last_tool_key = Some(key.clone());
key
}
fn tool_args_accum_of(&self, key: &ToolKey) -> String {
self.tool_args_accum
.iter()
.find(|(k, _)| k == key)
.map(|(_, v)| v.clone())
.unwrap_or_default()
}
fn set_tool_args_accum(&mut self, key: &ToolKey, value: String) {
match self.tool_args_accum.iter_mut().find(|(k, _)| k == key) {
Some(slot) => slot.1 = value,
None => self.tool_args_accum.push((key.clone(), value)),
}
}
fn close_content_blocks(&mut self, events: &mut Vec<StreamEvent>) {
if self.blocks_closed {
return;
}
self.blocks_closed = true;
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));
}
}
fn emit_message_end(&mut self, events: &mut Vec<StreamEvent>, stop_reason: &str) {
if self.message_closed {
return;
}
self.message_closed = true;
self.pending_stop_reason = None;
let mut delta_json = json!({
"type": "message_delta",
"delta": { "stop_reason": stop_reason },
});
if let Some(usage) = &self.usage {
delta_json["usage"] = usage.to_json();
}
events.push(ev("message_delta", delta_json.to_string()));
let stop_json = json!({ "type": "message_stop" }).to_string();
events.push(ev("message_stop", stop_json));
}
pub fn convert(&mut self, data: &str) -> Result<(Vec<StreamEvent>, bool)> {
if data == "[DONE]" {
let mut events: Vec<StreamEvent> = Vec::new();
if let Some(stop_reason) = self.pending_stop_reason.clone() {
self.emit_message_end(&mut events, &stop_reason);
} else if self.message_started {
self.close_content_blocks(&mut events);
self.emit_message_end(&mut events, "end_turn");
}
return Ok((events, true));
}
let mut frame: Value = serde_json::from_str(data)
.map_err(|e| Error::other(format!("parse openai stream chunk: {e}")))?;
let raw_usage = frame.as_object_mut().and_then(|obj| obj.remove("usage"));
let chunk: OpenAIStreamChunk = serde_json::from_value(frame)
.map_err(|e| Error::other(format!("parse openai stream chunk: {e}")))?;
let frame_carries_usage = match read_stream_usage(raw_usage.as_ref()) {
Some(usage) => {
self.usage = Some(usage); true
}
None => false,
};
let mut events: Vec<StreamEvent> = Vec::new();
let choice = match chunk.choices.first() {
Some(c) => c,
None => {
if frame_carries_usage {
if let Some(stop_reason) = self.pending_stop_reason.clone() {
self.emit_message_end(&mut events, &stop_reason);
}
}
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 {
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.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 {
let tool_key = self.resolve_tool_key(tc);
if !self.tool_block_index.iter().any(|(k, _)| *k == tool_key) {
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((tool_key.clone(), self.block_index));
let mut content_block = Map::new();
content_block.insert("type".to_string(), Value::String("tool_use".to_string()));
if let Some(id) = &tc.id {
content_block.insert("id".to_string(), Value::String(id.clone()));
}
if let Some(name) = &tc.function.name {
content_block.insert("name".to_string(), Value::String(name.clone()));
}
content_block.insert("input".to_string(), Value::Object(Map::new()));
let block_json = json!({
"type": "content_block_start",
"index": self.block_index,
"content_block": content_block,
})
.to_string();
events.push(ev("content_block_start", block_json));
self.block_index += 1; }
let raw_args = tc.function.arguments.as_str();
if !raw_args.is_empty() {
let accum = self.tool_args_accum_of(&tool_key);
let emit = if !accum.is_empty()
&& raw_args.len() > accum.len()
&& raw_args.starts_with(&accum)
{
let diff = raw_args[accum.len()..].to_string();
self.set_tool_args_accum(&tool_key, raw_args.to_string());
diff
} else {
self.set_tool_args_accum(&tool_key, format!("{accum}{raw_args}"));
raw_args.to_string()
};
if !emit.is_empty() {
if let Some(idx) = self
.tool_block_index
.iter()
.find(|(k, _)| *k == tool_key)
.map(|(_, v)| *v)
{
let delta_json = json!({
"type": "content_block_delta",
"index": idx,
"delta": {
"type": "input_json_delta",
"partial_json": emit,
},
})
.to_string();
events.push(ev("content_block_delta", delta_json));
}
}
}
}
}
let finish = choice.finish_reason.as_deref().unwrap_or("");
if !finish.is_empty() {
let stop_reason = match finish {
"tool_calls" => "tool_use",
"length" => "max_tokens",
"stop" => "end_turn",
other => other,
};
if !self.message_closed && self.pending_stop_reason.is_none() {
self.close_content_blocks(&mut events);
if self.usage.is_some() {
self.emit_message_end(&mut events, stop_reason);
} else {
self.pending_stop_reason = Some(stop_reason.to_string());
}
}
}
if frame_carries_usage {
if let Some(stop_reason) = self.pending_stop_reason.clone() {
self.emit_message_end(&mut events, &stop_reason);
}
}
Ok((events, false))
}
pub fn flush(&mut self) -> Vec<StreamEvent> {
let mut events: Vec<StreamEvent> = Vec::new();
if let Some(stop_reason) = self.pending_stop_reason.clone() {
self.emit_message_end(&mut events, &stop_reason);
}
events
}
}
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;
use std::collections::HashMap;
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);
}
const USAGE_TAIL_FRAME: &str = r#"{"choices":[],"usage":{"prompt_tokens":13171,"completion_tokens":16,"total_tokens":13187,"completion_tokens_details":{"reasoning_tokens":14},"prompt_tokens_details":{"cached_tokens":13056}}}"#;
const GATEWAY_FAILED_FRAME: &str = r#"{"type":"managed_model_stream_failed","protocol":"managed-model.v2","stage":"provider","error":"gateway: tools[0].type:type cannot be empty. (kind=invalid_request, status=400)","errorCode":"invalid_request","errorContractVersion":1,"faultDomain":"provider","message":"","requestDisposition":"unknown","retryable":false,"requestId":"req-0001","consumeRequestId":"req-0001","providerRequestId":"prov-0001","transportRequestId":"trans-0001"}"#;
type Parsed = Vec<(String, Value)>;
fn content_chunk(text: &str) -> String {
json!({
"id": "c1",
"object": "chat.completion.chunk",
"choices": [{ "index": 0, "delta": { "content": text }, "finish_reason": null }],
})
.to_string()
}
fn finish_chunk(reason: &str, usage: Option<Value>) -> String {
let mut chunk = json!({
"id": "c1",
"object": "chat.completion.chunk",
"choices": [{ "index": 0, "delta": {}, "finish_reason": reason }],
});
if let Some(usage) = usage {
chunk["usage"] = usage;
}
chunk.to_string()
}
fn parse_events(events: &[StreamEvent]) -> Parsed {
events
.iter()
.map(|e| (e.event.clone(), serde_json::from_str(&e.data).unwrap()))
.collect()
}
fn event_names(events: &[(String, Value)]) -> Vec<&str> {
events.iter().map(|(name, _)| name.as_str()).collect()
}
fn count_events(events: &[(String, Value)], name: &str) -> usize {
events.iter().filter(|(n, _)| n == name).count()
}
fn feed(frames: &[&str]) -> (Vec<Vec<String>>, Parsed) {
let mut conv = new_openai_stream_converter();
let mut steps = Vec::new();
let mut all = Vec::new();
for frame in frames {
let parsed = parse_events(&conv.convert(frame).unwrap().0);
steps.push(parsed.iter().map(|(name, _)| name.clone()).collect());
all.extend(parsed);
}
(steps, all)
}
fn expect_single_close_at_end(all: &[(String, Value)]) -> &Value {
let names = event_names(all);
assert_eq!(count_events(all, "message_delta"), 1, "{names:?}");
assert_eq!(count_events(all, "message_stop"), 1, "{names:?}");
let stop_at = names.iter().position(|n| *n == "message_stop").unwrap();
assert_eq!(stop_at, names.len() - 1, "{names:?}");
assert_eq!(names[stop_at - 1], "message_delta", "{names:?}");
&all[stop_at - 1].1
}
#[test]
fn usage_tail_after_finish_reason_defers_close_to_tail_frame() {
let (steps, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("stop", None),
USAGE_TAIL_FRAME,
"[DONE]",
]);
assert_eq!(steps[1], ["content_block_stop"]); assert_eq!(steps[2], ["message_delta", "message_stop"]); assert!(steps[3].is_empty()); assert_eq!(count_events(&all, "content_block_stop"), 1); let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "end_turn" }));
assert_eq!(
delta["usage"],
json!({ "input_tokens": 13171, "output_tokens": 16 })
);
}
#[test]
fn usage_in_finish_reason_frame_closes_in_that_frame() {
let finish = finish_chunk(
"length",
Some(json!({ "prompt_tokens": 20, "completion_tokens": 3, "total_tokens": 23 })),
);
let (steps, all) = feed(&[&content_chunk("PONG"), &finish, "[DONE]"]);
assert_eq!(
steps[1],
["content_block_stop", "message_delta", "message_stop"]
);
assert!(steps[2].is_empty());
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "max_tokens" }));
assert_eq!(
delta["usage"],
json!({ "input_tokens": 20, "output_tokens": 3 })
);
}
#[test]
fn usage_on_choices_frame_during_deferral_closes_in_that_frame() {
let usage_frame = json!({
"id": "c1",
"choices": [{ "index": 0, "delta": {}, "finish_reason": null }],
"usage": { "prompt_tokens": 30, "completion_tokens": 4, "total_tokens": 34 },
})
.to_string();
let (steps, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("stop", None),
&usage_frame,
"[DONE]",
]);
assert_eq!(steps[1], ["content_block_stop"]);
assert_eq!(steps[2], ["message_delta", "message_stop"]);
assert!(steps[3].is_empty());
let delta = expect_single_close_at_end(&all);
assert_eq!(
delta["usage"],
json!({ "input_tokens": 30, "output_tokens": 4 })
);
}
#[test]
fn usage_before_finish_reason_closes_at_finish_with_latest_usage() {
let content_with_usage = |text: &str, completion_tokens: i64| {
json!({
"id": "c1",
"choices": [{ "index": 0, "delta": { "content": text }, "finish_reason": null }],
"usage": { "prompt_tokens": 7, "completion_tokens": completion_tokens },
})
.to_string()
};
let (steps, all) = feed(&[
&content_with_usage("PO", 1),
&content_with_usage("NG", 2),
&finish_chunk("stop", None),
"[DONE]",
]);
assert_eq!(
steps[2],
["content_block_stop", "message_delta", "message_stop"]
);
let delta = expect_single_close_at_end(&all);
assert_eq!(
delta["usage"],
json!({ "input_tokens": 7, "output_tokens": 2 })
);
}
#[test]
fn finish_reason_without_usage_closes_at_done_without_usage_key() {
let (steps, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("stop", None),
"[DONE]",
]);
assert_eq!(steps[1], ["content_block_stop"]);
assert_eq!(steps[2], ["message_delta", "message_stop"]);
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "end_turn" }));
assert!(delta.get("usage").is_none());
}
#[test]
fn only_first_finish_reason_counts() {
let (steps, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("length", None),
&finish_chunk("stop", None),
USAGE_TAIL_FRAME,
"[DONE]",
]);
assert!(steps[2].is_empty());
assert_eq!(steps[3], ["message_delta", "message_stop"]);
assert_eq!(count_events(&all, "content_block_stop"), 1);
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "max_tokens" }));
let finish_with_usage = finish_chunk(
"stop",
Some(json!({ "prompt_tokens": 1, "completion_tokens": 1 })),
);
let (steps, _) = feed(&[
&content_chunk("PONG"),
&finish_with_usage,
&finish_chunk("length", None),
]);
assert_eq!(
steps[1],
["content_block_stop", "message_delta", "message_stop"]
);
assert!(steps[2].is_empty());
}
#[test]
fn flush_emits_deferred_close_at_eof_exactly_once() {
let mut conv = new_openai_stream_converter();
let mut all = parse_events(&conv.convert(&content_chunk("PONG")).unwrap().0);
all.extend(parse_events(
&conv.convert(&finish_chunk("stop", None)).unwrap().0,
));
let flushed = parse_events(&conv.flush());
assert_eq!(event_names(&flushed), ["message_delta", "message_stop"]);
all.extend(flushed);
assert!(conv.flush().is_empty());
let delta = expect_single_close_at_end(&all);
assert!(delta.get("usage").is_none());
}
#[test]
fn flush_after_usage_tail_close_is_empty() {
let mut conv = new_openai_stream_converter();
conv.convert(&content_chunk("PONG")).unwrap();
conv.convert(&finish_chunk("stop", None)).unwrap();
let tail = parse_events(&conv.convert(USAGE_TAIL_FRAME).unwrap().0);
assert_eq!(event_names(&tail), ["message_delta", "message_stop"]);
assert!(conv.flush().is_empty());
}
#[test]
fn flush_does_not_fake_normal_end_for_truncated_stream() {
let mut conv = new_openai_stream_converter();
let opened = parse_events(&conv.convert(&content_chunk("PART")).unwrap().0);
assert_eq!(
event_names(&opened),
[
"message_start",
"content_block_start",
"content_block_delta"
]
);
assert!(conv.flush().is_empty());
}
#[test]
fn frames_without_choices_or_usage_emit_nothing_and_do_not_close_early() {
let mut conv = new_openai_stream_converter();
let no_choices_no_usage = r#"{"type":"managed_model_stream_failed","message":""}"#;
let empty_choices_null_usage = r#"{"id":"c1","choices":[],"usage":null}"#;
assert!(conv.convert(no_choices_no_usage).unwrap().0.is_empty());
conv.convert(&content_chunk("PONG")).unwrap();
let at_finish = parse_events(&conv.convert(&finish_chunk("stop", None)).unwrap().0);
assert_eq!(event_names(&at_finish), ["content_block_stop"]);
assert!(conv.convert(no_choices_no_usage).unwrap().0.is_empty());
assert!(conv.convert(empty_choices_null_usage).unwrap().0.is_empty());
let (end, done) = conv.convert("[DONE]").unwrap();
assert!(done);
let end = parse_events(&end);
assert_eq!(event_names(&end), ["message_delta", "message_stop"]);
assert!(end[0].1.get("usage").is_none());
}
#[test]
fn usage_frame_without_choices_key_closes_deferred_message() {
let bare_usage = r#"{"usage":{"prompt_tokens":5,"completion_tokens":6}}"#;
let (steps, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("stop", None),
bare_usage,
"[DONE]",
]);
assert_eq!(steps[2], ["message_delta", "message_stop"]);
assert!(steps[3].is_empty());
let delta = expect_single_close_at_end(&all);
assert_eq!(
delta["usage"],
json!({ "input_tokens": 5, "output_tokens": 6 })
);
}
#[test]
fn cached_and_reasoning_details_are_neither_mapped_nor_netted() {
let (_, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("stop", None),
USAGE_TAIL_FRAME,
"[DONE]",
]);
let usage = expect_single_close_at_end(&all)["usage"]
.as_object()
.unwrap();
let mut keys: Vec<&str> = usage.keys().map(String::as_str).collect();
keys.sort_unstable();
assert_eq!(keys, ["input_tokens", "output_tokens"]);
assert!(!usage.contains_key("cache_read_input_tokens"));
assert_eq!(usage["input_tokens"], json!(13171));
}
#[test]
fn missing_or_non_numeric_counts_are_omitted_not_zero() {
let usage_of = |usage: Value| {
let tail = json!({ "choices": [], "usage": usage }).to_string();
let (_, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("stop", None),
&tail,
"[DONE]",
]);
expect_single_close_at_end(&all)["usage"].clone()
};
assert_eq!(
usage_of(json!({ "prompt_tokens": null, "completion_tokens": 16 })),
json!({ "output_tokens": 16 })
);
assert_eq!(
usage_of(json!({ "prompt_tokens": 12, "completion_tokens": "16" })),
json!({ "input_tokens": 12 })
);
}
#[test]
fn non_object_usage_is_not_usage() {
for usage in [json!([13171, 16]), json!(29)] {
let tail = json!({ "choices": [], "usage": usage }).to_string();
let (steps, all) = feed(&[
&content_chunk("PONG"),
&finish_chunk("stop", None),
&tail,
"[DONE]",
]);
assert!(steps[2].is_empty(), "{usage}");
assert_eq!(steps[3], ["message_delta", "message_stop"], "{usage}");
assert!(
expect_single_close_at_end(&all).get("usage").is_none(),
"{usage}"
);
}
}
#[test]
fn gateway_error_frame_without_choices_parses_to_zero_events() {
let mut conv = new_openai_stream_converter();
assert!(conv.convert(GATEWAY_FAILED_FRAME).unwrap().0.is_empty());
assert!(conv.convert(GATEWAY_FAILED_FRAME).unwrap().0.is_empty());
let usage_only = r#"{"id":"c1","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}"#;
assert!(conv.convert(usage_only).unwrap().0.is_empty());
conv.convert(&content_chunk("PONG")).unwrap();
let end = parse_events(&conv.convert(&finish_chunk("stop", None)).unwrap().0);
assert_eq!(
event_names(&end),
["content_block_stop", "message_delta", "message_stop"]
);
assert_eq!(
end[1].1["usage"],
json!({ "input_tokens": 1, "output_tokens": 1 })
);
}
fn thinking_chunk(text: &str) -> String {
json!({ "id": "c1", "choices": [{ "index": 0, "delta": { "reasoning_content": text } }] })
.to_string()
}
fn tool_call_chunk(index: i64, id: &str, name: &str, args: &str) -> String {
json!({
"id": "c1",
"choices": [{
"index": 0,
"delta": {
"tool_calls": [
{ "index": index, "id": id, "function": { "name": name, "arguments": args } }
],
},
}],
})
.to_string()
}
fn run_chunks(chunks: &[&str]) -> Parsed {
let mut conv = new_openai_stream_converter();
let mut all = Vec::new();
for chunk in chunks {
all.extend(parse_events(&conv.convert(chunk).unwrap().0));
}
all.extend(parse_events(&conv.flush()));
all
}
fn assert_blocks_well_formed(events: &[(String, Value)]) -> HashMap<String, Vec<i64>> {
let mut open: HashMap<i64, String> = HashMap::new();
let mut type_of_index: HashMap<i64, String> = HashMap::new();
let mut start_index_by_type: HashMap<String, Vec<i64>> = HashMap::new();
for (name, payload) in events {
match name.as_str() {
"content_block_start" => {
let index = payload["index"].as_i64().unwrap();
let block_type = payload["content_block"]["type"]
.as_str()
.unwrap()
.to_string();
if let Some(previous) = type_of_index.get(&index) {
assert_eq!(previous, &block_type, "index {index} 被不同类型的块复用");
}
assert!(!open.contains_key(&index), "index {index} 已打开却又 start");
open.insert(index, block_type.clone());
type_of_index.insert(index, block_type.clone());
start_index_by_type
.entry(block_type)
.or_default()
.push(index);
}
"content_block_stop" => {
let index = payload["index"].as_i64().unwrap();
assert!(
open.remove(&index).is_some(),
"index {index} stop 但未处于打开态"
);
}
"content_block_delta" => {
let index = payload["index"].as_i64().unwrap();
assert!(
open.contains_key(&index),
"delta index {index} 不指向打开的块"
);
}
_ => {}
}
}
assert!(open.is_empty(), "仍有未关闭的块: {open:?}");
start_index_by_type
}
#[test]
fn thinking_then_tool_calls_do_not_share_an_index() {
let events = run_chunks(&[
&thinking_chunk("let me think"),
&thinking_chunk(" more"),
&tool_call_chunk(0, "call_1", "get_weather", r#"{"city":"#),
&tool_call_chunk(0, "call_1", "get_weather", r#""sf"}"#),
&finish_chunk("tool_calls", None),
]);
let by_type = assert_blocks_well_formed(&events);
assert_eq!(by_type["thinking"], [0]);
assert_eq!(by_type["tool_use"], [1]);
assert_eq!(
events.last().map(|(name, _)| name.as_str()),
Some("message_stop")
);
}
#[test]
fn thinking_text_tool_take_sequential_indexes() {
let events = run_chunks(&[
&thinking_chunk("reasoning"),
&content_chunk("hello"),
&tool_call_chunk(0, "call_1", "fn", "{}"),
&finish_chunk("tool_calls", None),
]);
let by_type = assert_blocks_well_formed(&events);
assert_eq!(by_type["thinking"], [0]);
assert_eq!(by_type["text"], [1]);
assert_eq!(by_type["tool_use"], [2]);
}
#[test]
fn text_only_block_pairs() {
let events = run_chunks(&[
&content_chunk("hi"),
&content_chunk(" there"),
&finish_chunk("stop", None),
]);
let by_type = assert_blocks_well_formed(&events);
assert_eq!(by_type["text"], [0]);
assert!(!by_type.contains_key("thinking"));
}
#[test]
fn thinking_only_block_closes_at_its_own_index() {
let events = run_chunks(&[&thinking_chunk("think"), &finish_chunk("stop", None)]);
let by_type = assert_blocks_well_formed(&events);
assert_eq!(by_type["thinking"], [0]);
}
#[test]
fn multiple_tool_calls_take_their_own_indexes() {
let events = run_chunks(&[
&thinking_chunk("plan"),
&tool_call_chunk(0, "c0", "a", "{}"),
&tool_call_chunk(1, "c1", "b", "{}"),
&finish_chunk("tool_calls", None),
]);
let by_type = assert_blocks_well_formed(&events);
assert_eq!(by_type["thinking"], [0]);
assert_eq!(by_type["tool_use"], [1, 2]);
}
#[test]
fn done_without_finish_reason_closes_blocks_and_ends_turn() {
let mut conv = new_openai_stream_converter();
let mut all = parse_events(
&conv
.convert(&tool_call_chunk(0, "call_1", "f", r#"{"a":1}"#))
.unwrap()
.0,
);
let (end, done) = conv.convert("[DONE]").unwrap();
assert!(done);
let end = parse_events(&end);
assert_eq!(
event_names(&end),
["content_block_stop", "message_delta", "message_stop"]
);
all.extend(end);
assert_blocks_well_formed(&all);
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "end_turn" }));
}
#[test]
fn done_after_finish_reason_does_not_close_twice() {
let (steps, all) = feed(&[
&tool_call_chunk(0, "call_1", "f", r#"{"a":1}"#),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert_eq!(steps[2], ["message_delta", "message_stop"]);
assert_blocks_well_formed(&all);
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "tool_use" }));
}
fn tool_first_chunk(index: i64, id: &str, name: &str) -> String {
json!({
"id": "c1",
"object": "chat.completion.chunk",
"choices": [{
"index": 0,
"delta": { "tool_calls": [{
"index": index,
"id": id,
"type": "function",
"function": { "name": name, "arguments": "" },
}] },
"finish_reason": null,
}],
})
.to_string()
}
fn tool_arg_chunk(index: i64, args: Value) -> String {
json!({
"id": "c1",
"object": "chat.completion.chunk",
"choices": [{
"index": 0,
"delta": { "tool_calls": [{ "index": index, "function": { "arguments": args } }] },
"finish_reason": null,
}],
})
.to_string()
}
fn tool_hollow_chunk(index: i64) -> String {
json!({
"id": "c1",
"object": "chat.completion.chunk",
"choices": [{
"index": 0,
"delta": { "tool_calls": [{ "index": index }] },
"finish_reason": null,
}],
})
.to_string()
}
fn tool_name_only_chunk(index: i64, name: &str) -> String {
json!({
"id": "c1",
"object": "chat.completion.chunk",
"choices": [{
"index": 0,
"delta": { "tool_calls": [{ "index": index, "function": { "name": name } }] },
"finish_reason": null,
}],
})
.to_string()
}
#[allow(clippy::type_complexity)]
fn feed_results(frames: &[&str]) -> (Vec<std::result::Result<Parsed, String>>, Parsed) {
let mut conv = new_openai_stream_converter();
let mut steps = Vec::new();
let mut all = Vec::new();
for frame in frames {
match conv.convert(frame) {
Ok((events, _)) => {
let parsed = parse_events(&events);
all.extend(parsed.clone());
steps.push(Ok(parsed));
}
Err(e) => steps.push(Err(e.to_string())),
}
}
(steps, all)
}
fn step_errors(steps: &[std::result::Result<Parsed, String>]) -> Vec<&String> {
steps.iter().filter_map(|s| s.as_ref().err()).collect()
}
fn partial_json_pieces(events: &Parsed) -> Vec<String> {
events
.iter()
.filter(|(name, payload)| {
name == "content_block_delta" && payload["delta"]["type"] == "input_json_delta"
})
.map(|(_, payload)| {
payload["delta"]["partial_json"]
.as_str()
.unwrap_or_default()
.to_string()
})
.collect()
}
#[test]
fn openai_spec_toolcall_continuation_frames_carry_no_name() {
let (steps, all) = feed_results(&[
&tool_first_chunk(0, "call_1", "get_weather"),
&tool_arg_chunk(0, json!(r#"{"city":"#)),
&tool_arg_chunk(0, json!(r#" "SF"}"#)),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
assert_eq!(partial_json_pieces(&all).concat(), r#"{"city": "SF"}"#);
let by_type = assert_blocks_well_formed(&all);
assert_eq!(by_type["tool_use"], [0]);
assert_eq!(count_events(&all, "message_stop"), 1);
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "tool_use" }));
}
#[test]
fn toolcall_delta_without_function_emits_no_delta() {
let (steps, all) = feed_results(&[
&tool_first_chunk(0, "call_1", "get_weather"),
&tool_hollow_chunk(0),
&tool_name_only_chunk(0, "get_weather"),
&tool_arg_chunk(0, json!("{}")),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
assert_eq!(steps[1].as_ref().map(|p| event_names(p)), Ok(Vec::new()));
assert_eq!(steps[2].as_ref().map(|p| event_names(p)), Ok(Vec::new()));
assert_eq!(partial_json_pieces(&all), ["{}"]);
assert_eq!(assert_blocks_well_formed(&all)["tool_use"], [0]);
}
#[test]
fn choice_without_index_is_not_a_stream_error() {
let no_index = r#"{"id":"c1","choices":[{"delta":{"content":"hi"}}]}"#;
let (steps, all) = feed_results(&[no_index, &finish_chunk("stop", None), "[DONE]"]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let texts: Vec<&str> = all
.iter()
.filter(|(name, p)| name == "content_block_delta" && p["delta"]["type"] == "text_delta")
.map(|(_, p)| p["delta"]["text"].as_str().unwrap_or_default())
.collect();
assert_eq!(texts, ["hi"]);
assert_eq!(assert_blocks_well_formed(&all)["text"], [0]);
}
#[test]
fn toolcall_arguments_object_is_stringified_not_rejected() {
let (steps, all) = feed_results(&[
&tool_first_chunk(0, "call_1", "get_weather"),
&tool_arg_chunk(0, json!({ "city": "sf" })),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let joined = partial_json_pieces(&all).concat();
assert!(!joined.contains("[object Object]"), "{joined}");
assert_eq!(
serde_json::from_str::<Value>(&joined).unwrap(),
json!({ "city": "sf" })
);
}
#[test]
fn full_args_resend_upstream_yields_one_valid_json() {
let (steps, all) = feed_results(&[
&tool_first_chunk(0, "call_1", "f"),
&tool_arg_chunk(0, json!(r#"{"a":"#)),
&tool_arg_chunk(0, json!(r#"{"a":1"#)),
&tool_arg_chunk(0, json!(r#"{"a":1}"#)),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let joined = partial_json_pieces(&all).concat();
assert_eq!(joined, r#"{"a":1}"#);
assert_eq!(
serde_json::from_str::<Value>(&joined).unwrap(),
json!({ "a": 1 })
);
}
#[test]
fn true_incremental_args_are_still_forwarded_piece_by_piece() {
let (steps, all) = feed_results(&[
&tool_first_chunk(0, "call_1", "f"),
&tool_arg_chunk(0, json!(r#"{"city":"#)),
&tool_arg_chunk(0, json!(r#""san francisco"}"#)),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let pieces = partial_json_pieces(&all);
assert_eq!(pieces, [r#"{"city":"#, r#""san francisco"}"#]);
let joined = pieces.concat();
assert_eq!(joined, r#"{"city":"san francisco"}"#);
assert_eq!(
serde_json::from_str::<Value>(&joined).unwrap(),
json!({ "city": "san francisco" })
);
}
fn tool_call_chunk_without_index(id: &str, name: &str, args: &str) -> String {
json!({
"id": "c1",
"choices": [{
"index": 0,
"delta": { "tool_calls": [{
"id": id,
"type": "function",
"function": { "name": name, "arguments": args },
}] },
}],
})
.to_string()
}
fn tool_arg_chunk_anonymous(args: &str) -> String {
json!({
"id": "c1",
"choices": [{
"index": 0,
"delta": { "tool_calls": [{ "function": { "arguments": args } }] },
}],
})
.to_string()
}
fn tool_call_chunk_index_only(index: i64, args: &str) -> String {
json!({
"id": "c1",
"choices": [{
"index": 0,
"delta": { "tool_calls": [{ "index": index, "function": { "arguments": args } }] },
}],
})
.to_string()
}
fn tool_use_content_blocks(events: &Parsed) -> Vec<Value> {
events
.iter()
.filter(|(name, p)| {
name == "content_block_start" && p["content_block"]["type"] == "tool_use"
})
.map(|(_, p)| p["content_block"].clone())
.collect()
}
fn partial_json_by_block(events: &Parsed) -> Vec<(i64, String)> {
let mut out: Vec<(i64, String)> = Vec::new();
for (name, payload) in events {
if name != "content_block_delta" || payload["delta"]["type"] != "input_json_delta" {
continue;
}
let index = payload["index"].as_i64().unwrap_or(-1);
let piece = payload["delta"]["partial_json"]
.as_str()
.unwrap_or_default();
match out.iter_mut().find(|(i, _)| *i == index) {
Some(slot) => slot.1.push_str(piece),
None => out.push((index, piece.to_string())),
}
}
out
}
#[test]
fn two_index_less_toolcalls_do_not_share_a_block() {
let (steps, all) = feed_results(&[
&tool_call_chunk_without_index("call_1", "a", r#"{"x":1}"#),
&tool_call_chunk_without_index("call_2", "b", r#"{"y":2}"#),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let by_type = assert_blocks_well_formed(&all);
assert_eq!(by_type["tool_use"], [0, 1]);
let args = partial_json_by_block(&all);
assert_eq!(
args,
[(0, r#"{"x":1}"#.to_string()), (1, r#"{"y":2}"#.to_string())]
);
for (_, piece) in &args {
serde_json::from_str::<Value>(piece).expect("每块参数必须各自合法");
}
let blocks = tool_use_content_blocks(&all);
assert_eq!(blocks[0]["id"], json!("call_1"));
assert_eq!(blocks[0]["name"], json!("a"));
assert_eq!(blocks[1]["id"], json!("call_2"));
assert_eq!(blocks[1]["name"], json!("b"));
}
#[test]
fn two_indexed_toolcalls_still_take_their_own_blocks() {
let (steps, all) = feed_results(&[
&tool_call_chunk(0, "call_1", "a", r#"{"x":1}"#),
&tool_call_chunk(1, "call_2", "b", r#"{"y":2}"#),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
assert_eq!(assert_blocks_well_formed(&all)["tool_use"], [0, 1]);
assert_eq!(
partial_json_by_block(&all),
[(0, r#"{"x":1}"#.to_string()), (1, r#"{"y":2}"#.to_string())]
);
}
#[test]
fn anonymous_continuation_fragments_stay_on_the_last_tool_key() {
let (steps, all) = feed_results(&[
&tool_call_chunk_without_index("call_1", "f", r#"{"a":"#),
&tool_arg_chunk_anonymous("1}"),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
assert_eq!(assert_blocks_well_formed(&all)["tool_use"], [0]);
assert_eq!(partial_json_by_block(&all), [(0, r#"{"a":1}"#.to_string())]);
}
#[test]
fn missing_id_and_name_keys_are_omitted_not_empty_strings() {
let (steps, all) = feed_results(&[
&tool_call_chunk_index_only(0, r#"{"a":1}"#),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let blocks = tool_use_content_blocks(&all);
assert_eq!(blocks.len(), 1);
let block = blocks[0].as_object().expect("content_block 是对象");
assert!(!block.contains_key("id"), "{block:?}");
assert!(!block.contains_key("name"), "{block:?}");
assert_eq!(block["type"], json!("tool_use"));
assert_eq!(block["input"], json!({}));
assert!(!block.values().any(Value::is_null), "{block:?}");
}
#[test]
fn present_id_and_name_keys_are_written_through() {
let (steps, all) = feed_results(&[
&tool_first_chunk(0, "call_1", "get_weather"),
&finish_chunk("tool_calls", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let blocks = tool_use_content_blocks(&all);
assert_eq!(blocks[0]["id"], json!("call_1"));
assert_eq!(blocks[0]["name"], json!("get_weather"));
}
#[test]
fn text_then_thinking_do_not_share_an_index() {
let events = run_chunks(&[
&content_chunk("hello"),
&thinking_chunk("thinking"),
&finish_chunk("stop", None),
]);
let by_type = assert_blocks_well_formed(&events);
assert_eq!(by_type["text"], [0]);
assert_eq!(by_type["thinking"], [1]);
let thinking_delta_index = events
.iter()
.find(|(name, p)| {
name == "content_block_delta" && p["delta"]["type"] == "thinking_delta"
})
.map(|(_, p)| p["index"].as_i64().unwrap_or(-1));
assert_eq!(thinking_delta_index, Some(1));
}
#[test]
fn thinking_then_text_order_is_unchanged() {
let events = run_chunks(&[
&thinking_chunk("thinking"),
&content_chunk("hello"),
&finish_chunk("stop", None),
]);
let by_type = assert_blocks_well_formed(&events);
assert_eq!(by_type["thinking"], [0]);
assert_eq!(by_type["text"], [1]);
}
#[test]
fn choice_without_delta_is_not_a_stream_error() {
let bare_choice = r#"{"id":"c1","choices":[{"index":0}]}"#;
let finish_without_delta = r#"{"id":"c1","choices":[{"index":0,"finish_reason":"stop"}]}"#;
let (steps, all) = feed_results(&[
&content_chunk("hi"),
bare_choice,
finish_without_delta,
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
assert_eq!(steps[1].as_ref().map(|p| event_names(p)), Ok(Vec::new()));
assert_blocks_well_formed(&all);
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "end_turn" }));
}
#[test]
fn choice_with_delta_still_emits_its_content() {
let (steps, all) = feed_results(&[
&content_chunk("hi"),
&content_chunk(" there"),
&finish_chunk("stop", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
let texts: Vec<&str> = all
.iter()
.filter(|(name, p)| name == "content_block_delta" && p["delta"]["type"] == "text_delta")
.map(|(_, p)| p["delta"]["text"].as_str().unwrap_or_default())
.collect();
assert_eq!(texts, ["hi", " there"]);
}
fn stop_reason_for(reason: &str) -> String {
let (steps, all) =
feed_results(&[&content_chunk("hi"), &finish_chunk(reason, None), "[DONE]"]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
expect_single_close_at_end(&all)["delta"]["stop_reason"]
.as_str()
.unwrap_or_default()
.to_string()
}
#[test]
fn unlisted_finish_reason_is_passed_through() {
assert_eq!(stop_reason_for("content_filter"), "content_filter");
assert_eq!(stop_reason_for("function_call"), "function_call");
}
#[test]
fn listed_finish_reasons_still_map_to_anthropic_stop_reasons() {
assert_eq!(stop_reason_for("stop"), "end_turn");
assert_eq!(stop_reason_for("tool_calls"), "tool_use");
assert_eq!(stop_reason_for("length"), "max_tokens");
}
#[test]
fn non_array_choices_yields_zero_events_not_a_stream_error() {
let bogus = r#"{"id":"c1","choices":{"0":{"index":0,"delta":{"content":"x"}}}}"#;
let (steps, all) = feed_results(&[
&content_chunk("hi"),
bogus,
&finish_chunk("stop", None),
"[DONE]",
]);
assert!(step_errors(&steps).is_empty(), "{:?}", step_errors(&steps));
assert_eq!(steps[1].as_ref().map(|p| event_names(p)), Ok(Vec::new()));
assert_blocks_well_formed(&all);
let delta = expect_single_close_at_end(&all);
assert_eq!(delta["delta"], json!({ "stop_reason": "end_turn" }));
}
const TOOLCALL_RESPONSE_CONTENT_NULL: &[u8] = br#"{"id":"c1","object":"chat.completion","model":"m","choices":[{"index":0,"message":{"role":"assistant","content":null,"tool_calls":[{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{\"city\":\"SF\"}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3}}"#;
const TOOLCALL_RESPONSE_CONTENT_ABSENT: &[u8] = br#"{"id":"c1","object":"chat.completion","model":"m","choices":[{"index":0,"message":{"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{\"city\":\"SF\"}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3}}"#;
const TOOLCALL_RESPONSE_WITH_TEXT: &[u8] = br#"{"id":"c1","object":"chat.completion","model":"m","choices":[{"index":0,"message":{"role":"assistant","content":"let me check","tool_calls":[{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{\"city\":\"SF\"}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3}}"#;
fn block_types(resp: &ChatResponse) -> Vec<&str> {
resp.content.iter().map(|b| b.r#type.as_str()).collect()
}
#[test]
fn null_content_with_tool_calls_yields_tool_use_and_no_empty_text_block() {
let resp = parse_response(TOOLCALL_RESPONSE_CONTENT_NULL).unwrap();
assert_eq!(block_types(&resp), ["tool_use"]);
assert_eq!(resp.content[0].id.as_deref(), Some("call_1"));
assert_eq!(resp.content[0].name.as_deref(), Some("get_weather"));
assert_eq!(resp.content[0].input, Some(json!({ "city": "SF" })));
assert_eq!(resp.stop_reason, "tool_use");
let anthropic = parse_openai_response_to_anthropic(TOOLCALL_RESPONSE_CONTENT_NULL).unwrap();
assert_eq!(
anthropic
.content
.iter()
.map(|b| b.r#type.as_str())
.collect::<Vec<_>>(),
["tool_use"]
);
let with_text = parse_response(TOOLCALL_RESPONSE_WITH_TEXT).unwrap();
assert_eq!(block_types(&with_text), ["text", "tool_use"]);
assert_eq!(with_text.content[0].text.as_deref(), Some("let me check"));
}
#[test]
fn absent_content_key_is_decoded_like_an_empty_one() {
let resp = parse_response(TOOLCALL_RESPONSE_CONTENT_ABSENT).unwrap();
assert_eq!(block_types(&resp), ["tool_use"]);
assert_eq!(resp.content[0].name.as_deref(), Some("get_weather"));
let anthropic =
parse_openai_response_to_anthropic(TOOLCALL_RESPONSE_CONTENT_ABSENT).unwrap();
assert_eq!(anthropic.content.len(), 1);
}
#[test]
fn missing_choices_response_yields_zero_blocks_not_a_decode_error() {
let no_choices = br#"{"id":"c1","object":"chat.completion","model":"m","usage":{"prompt_tokens":3,"completion_tokens":5,"total_tokens":8}}"#;
let resp = parse_response(no_choices).expect("missing choices must not fail the response");
assert!(block_types(&resp).is_empty());
assert_eq!(resp.id, "c1");
assert_eq!(resp.model, "m");
assert_eq!(resp.usage.input_tokens, 3);
assert_eq!(resp.usage.output_tokens, 5);
assert_eq!(resp.stop_reason, "");
let anthropic = parse_openai_response_to_anthropic(no_choices)
.expect("missing choices must not fail the anthropic projection");
assert!(anthropic.content.is_empty());
assert_eq!(anthropic.usage.input_tokens, 3);
}
#[test]
fn null_choices_response_yields_zero_blocks_not_a_decode_error() {
let null_choices = br#"{"id":"c1","object":"chat.completion","model":"m","choices":null,"usage":{"prompt_tokens":3,"completion_tokens":5,"total_tokens":8}}"#;
let resp = parse_response(null_choices).expect("null choices must not fail the response");
assert!(block_types(&resp).is_empty());
assert_eq!(resp.id, "c1");
assert_eq!(resp.usage.input_tokens, 3);
assert_eq!(resp.stop_reason, "");
let anthropic = parse_openai_response_to_anthropic(null_choices)
.expect("null choices must not fail the anthropic projection");
assert!(anthropic.content.is_empty());
assert_eq!(anthropic.usage.input_tokens, 3);
}
#[test]
fn present_choices_still_yield_content_blocks() {
let resp =
parse_response(TOOLCALL_RESPONSE_WITH_TEXT).expect("choices present must decode");
assert_eq!(block_types(&resp), ["text", "tool_use"]);
assert_eq!(resp.stop_reason, "tool_use");
let anthropic = parse_openai_response_to_anthropic(TOOLCALL_RESPONSE_WITH_TEXT)
.expect("choices present must decode");
assert_eq!(anthropic.content.len(), 2);
}
#[test]
fn null_finish_reason_is_not_a_decode_failure() {
let body = br#"{"id":"c1","object":"chat.completion","model":"m","choices":[{"index":0,"message":{"role":"assistant","content":"hi"},"finish_reason":null}],"usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3}}"#;
let resp = parse_response(body).unwrap();
assert_eq!(resp.stop_reason, "");
assert_eq!(block_types(&resp), ["text"]);
let stopped = br#"{"id":"c1","object":"chat.completion","model":"m","choices":[{"index":0,"message":{"role":"assistant","content":"hi"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3}}"#;
assert_eq!(parse_response(stopped).unwrap().stop_reason, "end_turn");
}
}