Skip to content

Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.

Rust

fix(translation): Preserve "phase" on OpenAI messages (#1246)

Graham Kingef958a9a8099
diff --git a/crates/libsy-llm-client/src/run.rs b/crates/libsy-llm-client/src/run.rs
index 5646344aa..d0d64fc59 100644
--- a/crates/libsy-llm-client/src/run.rs
+++ b/crates/libsy-llm-client/src/run.rs
@@ -1075,10 +1075,12 @@ impl ClientRouter {
return Ok(());
}
let mut segment = input.messages.to_vec();
- segment.extend(response.outputs.iter().map(|output| Message {
- role: output.role,
- content: output.content.clone(),
- }));
+ segment.extend(
+ response
+ .outputs
+ .iter()
+ .map(|output| Message::new(output.role, output.content.clone())),
+ );
let history = Arc::new(MessageHistory::new(
input.parent.clone(),
Arc::from(segment),
@@ -2134,16 +2136,16 @@ mod tests {
.extensions
.fields
.insert("previous_response_id".to_string(), json!("msg_stream"));
- follow.llm_request.messages = vec![Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ follow.llm_request.messages = vec![Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "toolu_stream".to_string(),
content: vec![ContentBlock::Text {
text: "ready".to_string(),
}],
is_error: None,
})],
- }];
+ )];
assert!(clients.stored_state_owner(&follow).is_none());
response
.llm_response
diff --git a/crates/libsy-llm-client/tests/observability.rs b/crates/libsy-llm-client/tests/observability.rs
index 1177a2532..daf67947b 100644
--- a/crates/libsy-llm-client/tests/observability.rs
+++ b/crates/libsy-llm-client/tests/observability.rs
@@ -724,14 +724,14 @@ async fn affinity_warns_once_when_request_has_no_usable_identity() -> switchyard
})?);
let request = Request {
llm_request: LlmRequest {
- messages: vec![Message {
- role: Role::User,
- content: vec![ContentBlock::Reasoning {
+ messages: vec![Message::new(
+ Role::User,
+ vec![ContentBlock::Reasoning {
text: "provider reasoning".to_string(),
signature: None,
details: Vec::new(),
}],
- }],
+ )],
..LlmRequest::default()
},
raw_request: None,
@@ -1277,24 +1277,24 @@ async fn stage_router_records_algorithm_owned_metrics() -> switchyard_libsy::Res
model: Some("auto".to_string()),
messages: vec![
Message::text(Role::User, "fix the build"),
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: "call_1".to_string(),
name: "Bash".to_string(),
arguments: json!({"command": "cargo test"}),
})],
- },
- Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ ),
+ Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "call_1".to_string(),
content: vec![ContentBlock::Text {
text: "fatal runtime error: out of memory".to_string(),
}],
is_error: Some(true),
})],
- },
+ ),
],
..LlmRequest::default()
},
diff --git a/crates/libsy/src/algorithms/advisor_gate.rs b/crates/libsy/src/algorithms/advisor_gate.rs
index 91a9acc07..217977a3f 100644
--- a/crates/libsy/src/algorithms/advisor_gate.rs
+++ b/crates/libsy/src/algorithms/advisor_gate.rs
@@ -390,10 +390,7 @@ impl AdvisorGate {
.llm_request
.instructions
.iter()
- .map(|block| Message {
- role: block.role,
- content: block.content.clone(),
- })
+ .map(|block| Message::new(block.role, block.content.clone()))
.chain(base.llm_request.messages.iter().cloned())
.collect();
let transcript = review_transcript(
diff --git a/crates/libsy/src/algorithms/advisor_gate/signals.rs b/crates/libsy/src/algorithms/advisor_gate/signals.rs
index 8209a8125..7524337ba 100644
--- a/crates/libsy/src/algorithms/advisor_gate/signals.rs
+++ b/crates/libsy/src/algorithms/advisor_gate/signals.rs
@@ -65,16 +65,16 @@ mod tests {
messages: vec![
Message::text(Role::User, "build X"),
Message::text(Role::Assistant, "working"),
- Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "t1".to_string(),
content: vec![ContentBlock::Text {
text: "ok".to_string(),
}],
is_error: None,
})],
- },
+ ),
],
..LlmRequest::default()
},
diff --git a/crates/libsy/src/algorithms/advisor_gate/tests.rs b/crates/libsy/src/algorithms/advisor_gate/tests.rs
index b59e549e8..7a2ffbbd3 100644
--- a/crates/libsy/src/algorithms/advisor_gate/tests.rs
+++ b/crates/libsy/src/algorithms/advisor_gate/tests.rs
@@ -958,16 +958,16 @@ async fn min_tool_results_defers_gate() {
// Once the conversation carries a tool result, the gate fires.
let with_result = request(vec![
Message::text(Role::User, "build X"),
- Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "t1".to_string(),
content: vec![ContentBlock::Text {
text: "ok".to_string(),
}],
is_error: None,
})],
- },
+ ),
]);
let serve = script.serve("APPROVE", |_| reply("done"));
test_drive(gate, with_result, serve).await.expect("routes");
@@ -994,10 +994,7 @@ async fn min_tool_results_counts_batched_result_blocks() {
};
let batched = request(vec![
Message::text(Role::User, "build X"),
- Message {
- role: Role::User,
- content: vec![tool_result("t1"), tool_result("t2")],
- },
+ Message::new(Role::User, vec![tool_result("t1"), tool_result("t2")]),
]);
let serve = script.serve("APPROVE", |_| reply("done"));
test_drive(gate, batched, serve).await.expect("routes");
diff --git a/crates/libsy/src/algorithms/escalation.rs b/crates/libsy/src/algorithms/escalation.rs
index 9279260dd..f0836f911 100644
--- a/crates/libsy/src/algorithms/escalation.rs
+++ b/crates/libsy/src/algorithms/escalation.rs
@@ -59,13 +59,13 @@ fn clear_streak(state: &mut State) {
}
fn assistant_message(response: &AggLlmResponse) -> Message {
- Message {
- role: Role::Assistant,
- content: response
+ Message::new(
+ Role::Assistant,
+ response
.first_output()
.map(|output| output.content.clone())
.unwrap_or_default(),
- }
+ )
}
/// Calls the efficient model, judges its response, and latches to capable once the streak
diff --git a/crates/libsy/src/algorithms/llm_class.rs b/crates/libsy/src/algorithms/llm_class.rs
index 48486ca5f..10d0be8d4 100644
--- a/crates/libsy/src/algorithms/llm_class.rs
+++ b/crates/libsy/src/algorithms/llm_class.rs
@@ -178,14 +178,16 @@ fn task_messages(messages: &[Message]) -> Vec<Message> {
[Some(opening_task), user_messages.next_back()]
.into_iter()
.flatten()
- .map(|message| Message {
- role: Role::User,
- content: message
- .content
- .iter()
- .filter(|block| is_task_content(block))
- .cloned()
- .collect(),
+ .map(|message| {
+ Message::new(
+ Role::User,
+ message
+ .content
+ .iter()
+ .filter(|block| is_task_content(block))
+ .cloned()
+ .collect(),
+ )
})
.collect()
}
@@ -1560,9 +1562,9 @@ mod tests {
..DecisionJudgeConfig::default()
};
let mut request = classify_session_request();
- request.llm_request.messages.push(Message {
- role: Role::Assistant,
- content: vec![
+ request.llm_request.messages.push(Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Reasoning {
text: "private reasoning".into(),
signature: None,
@@ -1572,7 +1574,7 @@ mod tests {
text: "visible progress".into(),
},
],
- });
+ ));
request
.llm_request
.messages
@@ -2155,27 +2157,27 @@ mod tests {
}
fn tool_call(id: &str) -> Message {
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: id.to_string(),
name: "search".to_string(),
arguments: Value::Null,
})],
- }
+ )
}
fn tool_result(id: &str) -> Message {
- Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: id.to_string(),
content: vec![ContentBlock::Text {
text: "tool output".to_string(),
}],
is_error: None,
})],
- }
+ )
}
#[test]
@@ -2334,9 +2336,9 @@ mod tests {
let messages = vec![
Message::text(Role::System, "client instructions"),
Message::text(Role::User, "initial task"),
- Message {
- role: Role::Assistant,
- content: vec![
+ Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Reasoning {
text: "private chain of thought".to_string(),
signature: None,
@@ -2346,17 +2348,17 @@ mod tests {
text: "visible answer".to_string(),
},
],
- },
+ ),
tool_call("call-1"),
tool_result("call-1"),
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::Reasoning {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::Reasoning {
text: "reasoning-only turn".to_string(),
signature: None,
details: Vec::new(),
}],
- },
+ ),
Message::text(Role::User, "follow-up"),
];
let request = Request {
diff --git a/crates/libsy/src/algorithms/util/affinity.rs b/crates/libsy/src/algorithms/util/affinity.rs
index a325d6aca..6d4b88199 100644
--- a/crates/libsy/src/algorithms/util/affinity.rs
+++ b/crates/libsy/src/algorithms/util/affinity.rs
@@ -677,9 +677,9 @@ mod tests {
metadata: None,
};
let text_only = request(Message::text(Role::User, "Implement the parser."));
- let text_with_reasoning = request(Message {
- role: Role::User,
- content: vec![
+ let text_with_reasoning = request(Message::new(
+ Role::User,
+ vec![
ContentBlock::Text {
text: "Implement the parser.".to_string(),
},
@@ -689,7 +689,7 @@ mod tests {
details: Vec::new(),
},
],
- });
+ ));
assert_eq!(
first_user_message_hash(&text_only),
@@ -944,14 +944,14 @@ mod tests {
// A tool continuation holds the assignment, so no judge call.
let mut continued = opening.clone();
- continued.llm_request.messages.push(Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ continued.llm_request.messages.push(Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "call-1".to_string(),
content: Vec::new(),
is_error: None,
})],
- });
+ ));
assert_eq!(
scores(&router, &mut state, &mut continued)
.await?
@@ -990,14 +990,14 @@ mod tests {
// The new turn's tool continuation is not held on the earlier turn's model.
let mut continued = spoke.clone();
- continued.llm_request.messages.push(Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ continued.llm_request.messages.push(Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "call-1".to_string(),
content: Vec::new(),
is_error: None,
})],
- });
+ ));
assert!(
scores(&router, &mut state, &mut continued)
.await?
diff --git a/crates/libsy/src/algorithms/util/tier_fixtures.rs b/crates/libsy/src/algorithms/util/tier_fixtures.rs
index 1e126e3f1..b69bd4a82 100644
--- a/crates/libsy/src/algorithms/util/tier_fixtures.rs
+++ b/crates/libsy/src/algorithms/util/tier_fixtures.rs
@@ -94,24 +94,24 @@ pub(crate) fn turn_request(failed: bool) -> Request {
model: Some("auto".to_string()),
messages: vec![
Message::text(Role::User, "fix the build"),
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: "call_1".to_string(),
name: "Bash".to_string(),
arguments: json!({"command": "cargo test"}),
})],
- },
- Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ ),
+ Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "call_1".to_string(),
content: vec![ContentBlock::Text {
text: content.to_string(),
}],
is_error: Some(failed),
})],
- },
+ ),
],
..LlmRequest::default()
},
diff --git a/crates/libsy/src/algorithms/util/tool_signals.rs b/crates/libsy/src/algorithms/util/tool_signals.rs
index f4d590e6d..011d72378 100644
--- a/crates/libsy/src/algorithms/util/tool_signals.rs
+++ b/crates/libsy/src/algorithms/util/tool_signals.rs
@@ -1766,40 +1766,40 @@ mod tests {
// assistant message with a single named tool call
fn tc(name: &str) -> Message {
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: String::new(),
name: name.to_string(),
arguments: json!({}),
})],
- }
+ )
}
// assistant Bash message carrying `command`
fn bash(command: &str) -> Message {
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: String::new(),
name: "Bash".to_string(),
arguments: json!({"command": command}),
})],
- }
+ )
}
// a tool result message (goes in a user-role message, as in Anthropic's normalised form)
fn tr(text: &str) -> Message {
- Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: String::new(),
content: vec![ContentBlock::Text {
text: text.to_string(),
}],
is_error: None,
})],
- }
+ )
}
#[test]
@@ -2099,23 +2099,27 @@ mod tests {
#[test]
fn retrieved_file_contents_are_ignored() {
- let call = |id: &str, name: &str, arguments: Value| Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
- id: id.to_string(),
- name: name.to_string(),
- arguments,
- })],
+ let call = |id: &str, name: &str, arguments: Value| {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
+ id: id.to_string(),
+ name: name.to_string(),
+ arguments,
+ })],
+ )
};
- let result = |id: &str, text: &str| Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
- tool_call_id: id.to_string(),
- content: vec![ContentBlock::Text {
- text: text.to_string(),
- }],
- is_error: None,
- })],
+ let result = |id: &str, text: &str| {
+ Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
+ tool_call_id: id.to_string(),
+ content: vec![ContentBlock::Text {
+ text: text.to_string(),
+ }],
+ is_error: None,
+ })],
+ )
};
let signal = extract_tool_signals_with_window(
&with_messages(vec![
@@ -2260,14 +2264,14 @@ mod tests {
"exit_code": exit_code,
"error": null,
});
- let call = Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ let call = Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: String::new(),
name: "terminal".to_string(),
arguments: json!({"command": "cat run.log"}),
})],
- };
+ );
ToolSignals::from_request(&call_with_result(call, tr(&output.to_string())), None)
.severity
};
@@ -2414,13 +2418,13 @@ mod tests {
.map(|call_id| {
let mut raw = raw.clone();
raw["call_id"] = json!(call_id);
- Message {
- role: Role::User,
- content: vec![ContentBlock::Unknown {
+ Message::new(
+ Role::User,
+ vec![ContentBlock::Unknown {
provider: WireFormat::OpenAiResponses.into(),
raw,
}],
- }
+ )
})
.collect(),
);
@@ -2452,13 +2456,13 @@ mod tests {
};
for index in 0..3 {
success["call_id"] = json!(format!("success_{index}"));
- request.llm_request.messages.push(Message {
- role: Role::User,
- content: vec![ContentBlock::Unknown {
+ request.llm_request.messages.push(Message::new(
+ Role::User,
+ vec![ContentBlock::Unknown {
provider: WireFormat::OpenAiResponses.into(),
raw: success.clone(),
}],
- });
+ ));
}
let recovered = ToolSignals::from_request(&request, Some(3));
assert_eq!(recovered.severity, 0.0, "{raw}");
@@ -2483,15 +2487,15 @@ mod tests {
let request = with_messages(vec![
Message::text(Role::User, "do something"),
Message::text(Role::Assistant, "working"),
- Message {
- role: Role::User,
- content: vec![
+ Message::new(
+ Role::User,
+ vec![
result(vec![ContentBlock::Text {
text: "ok".to_string(),
}]),
result(Vec::new()),
],
- },
+ ),
tc("Bash"),
]);
let sig = ToolSignals::from_request(&request, None);
@@ -2534,14 +2538,14 @@ mod tests {
}
fn exec_command(cmd: Value) -> Message {
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: String::new(),
name: "exec_command".to_string(),
arguments: cmd,
})],
- }
+ )
}
#[test]
@@ -2859,14 +2863,14 @@ mod tests {
json!(r#"{"command":"view","path":"/app/main.py"}"#),
];
for arguments in arguments {
- let call = Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ let call = Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: String::new(),
name: "str_replace_based_edit_tool".to_string(),
arguments,
})],
- };
+ );
let request = with_messages(vec![call, tr("print('hi')")]);
let sig = ToolSignals::from_request(&request, None);
assert_eq!(sig.read_count, 1);
diff --git a/crates/libsy/src/algorithms/util/transcript.rs b/crates/libsy/src/algorithms/util/transcript.rs
index 751fc4fd2..5a5f2647f 100644
--- a/crates/libsy/src/algorithms/util/transcript.rs
+++ b/crates/libsy/src/algorithms/util/transcript.rs
@@ -125,9 +125,9 @@ mod tests {
#[test]
fn message_text_keeps_tool_calls_and_results() {
- let call = Message {
- role: Role::Assistant,
- content: vec![
+ let call = Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Text {
text: "running it".to_string(),
},
@@ -137,21 +137,21 @@ mod tests {
arguments: json!({"cmd": "ls"}),
}),
],
- };
+ );
let text = message_text(&call);
assert!(text.contains("running it"), "{text}");
assert!(text.contains(r#"tool_call bash({"cmd":"ls"})"#), "{text}");
- let result = Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ let result = Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "call-1".to_string(),
content: vec![ContentBlock::Text {
text: "no such file".to_string(),
}],
is_error: Some(true),
})],
- };
+ );
assert_eq!(message_text(&result), "no such file");
}
@@ -160,9 +160,9 @@ mod tests {
fn message_text_deduplicates_terminus_commands_for_the_judge() {
let first_command = "grep -n bug app.py\n";
let second_command = "sed -n '1,80p' app.py\n";
- let message = Message {
- role: Role::Assistant,
- content: vec![
+ let message = Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Text {
text: format!(
"Before\n```json\n{}\n```\nAfter",
@@ -186,7 +186,7 @@ mod tests {
arguments: json!({"keystrokes": second_command, "duration": 0.1}),
}),
],
- };
+ );
let text = message_text(&message);
@@ -211,9 +211,9 @@ mod tests {
})
.to_string()
};
- let message = Message {
- role: Role::Assistant,
- content: vec![
+ let message = Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Text {
text: format!(
"First {} second {} repeated {}",
@@ -233,7 +233,7 @@ mod tests {
arguments: json!({"keystrokes": second_command}),
}),
],
- };
+ );
let text = message_text(&message);
@@ -251,13 +251,13 @@ mod tests {
"commands": [{"keystrokes": command}],
})
.to_string();
- let without_tool_call = Message {
- role: Role::Assistant,
- content: vec![ContentBlock::Text { text: text.clone() }],
- };
- let mismatched_tool_call = Message {
- role: Role::Assistant,
- content: vec![
+ let without_tool_call = Message::new(
+ Role::Assistant,
+ vec![ContentBlock::Text { text: text.clone() }],
+ );
+ let mismatched_tool_call = Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Text { text },
ContentBlock::ToolCall(ToolCall {
id: "call-1".to_string(),
@@ -265,7 +265,7 @@ mod tests {
arguments: json!({"keystrokes": "sed -n '1,20p' app.py\n", "duration": 0.1}),
}),
],
- };
+ );
assert_eq!(
message_text(&without_tool_call)
@@ -286,9 +286,9 @@ mod tests {
fn message_text_keeps_a_partially_encoded_terminus_batch() {
let first_command = "grep -n bug app.py\n";
let second_command = "sed -n '1,80p' app.py\n";
- let message = Message {
- role: Role::Assistant,
- content: vec![
+ let message = Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Text {
text: json!({
"commands": [
@@ -304,7 +304,7 @@ mod tests {
arguments: json!({"keystrokes": first_command}),
}),
],
- };
+ );
let text = message_text(&message);
@@ -317,9 +317,9 @@ mod tests {
#[test]
fn message_text_keeps_duplicate_commands_without_one_tool_call_each() {
let command = "grep -n bug app.py\n";
- let message = Message {
- role: Role::Assistant,
- content: vec![
+ let message = Message::new(
+ Role::Assistant,
+ vec![
ContentBlock::Text {
text: json!({
"commands": [
@@ -335,7 +335,7 @@ mod tests {
arguments: json!({"keystrokes": command}),
}),
],
- };
+ );
let text = message_text(&message);
diff --git a/crates/libsy/src/algorithms/vgr/compaction.rs b/crates/libsy/src/algorithms/vgr/compaction.rs
index de2308aa1..99e883815 100644
--- a/crates/libsy/src/algorithms/vgr/compaction.rs
+++ b/crates/libsy/src/algorithms/vgr/compaction.rs
@@ -273,25 +273,25 @@ mod tests {
use switchyard_protocol::{LlmRequest, ToolCall, ToolResult};
fn call(id: &str, command: &str) -> Message {
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: id.into(),
name: "bash".into(),
arguments: serde_json::json!({ "command": command }),
})],
- }
+ )
}
fn result(id: &str, text: &str) -> Message {
- Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: id.into(),
content: vec![ContentBlock::Text { text: text.into() }],
is_error: None,
})],
- }
+ )
}
fn session(steps: usize) -> Request {
@@ -440,9 +440,9 @@ mod tests {
#[test]
fn batched_results_are_paired_by_tool_call_id() {
- let calls = Message {
- role: Role::Assistant,
- content: ["a", "b"]
+ let calls = Message::new(
+ Role::Assistant,
+ ["a", "b"]
.into_iter()
.map(|id| {
ContentBlock::ToolCall(ToolCall {
@@ -452,11 +452,11 @@ mod tests {
})
})
.collect(),
- };
+ );
for order in [["a", "b"], ["b", "a"]] {
- let results = Message {
- role: Role::Tool,
- content: order
+ let results = Message::new(
+ Role::Tool,
+ order
.into_iter()
.map(|id| {
ContentBlock::ToolResult(ToolResult {
@@ -468,7 +468,7 @@ mod tests {
})
})
.collect(),
- };
+ );
let view = digest(&[calls.clone(), results]);
assert!(view.contains("tool_a {}\nresult:\noutput_a"), "{view}");
assert!(
diff --git a/crates/libsy/src/algorithms/vgr/tests.rs b/crates/libsy/src/algorithms/vgr/tests.rs
index dfbd6394f..e414b2a24 100644
--- a/crates/libsy/src/algorithms/vgr/tests.rs
+++ b/crates/libsy/src/algorithms/vgr/tests.rs
@@ -19,25 +19,25 @@ pub(super) fn request(messages: Vec<Message>) -> Request {
}
pub(super) fn call(id: &str) -> Message {
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: id.into(),
name: "bash".into(),
arguments: serde_json::json!({"command": "ls"}),
})],
- }
+ )
}
pub(super) fn result(id: &str, text: &str) -> Message {
- Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: id.into(),
content: vec![ContentBlock::Text { text: text.into() }],
is_error: None,
})],
- }
+ )
}
fn branch(request: &Request, attempt: &str, task_type: Option<TaskType>) -> Branch {
@@ -157,15 +157,15 @@ fn missing_or_unrepresentable_evidence_fails_closed() {
assert_eq!(branch(&task, " ", None), Branch::Unknown);
assert_eq!(branch(&request(Vec::new()), "done", None), Branch::Unknown);
- let image = request(vec![Message {
- role: Role::User,
- content: vec![ContentBlock::Image {
+ let image = request(vec![Message::new(
+ Role::User,
+ vec![ContentBlock::Image {
source: ImageSource::Url {
url: "https://example.test/a.png".into(),
detail: None,
},
}],
- }]);
+ )]);
assert_eq!(branch(&image, "done", None), Branch::Unknown);
}
@@ -212,16 +212,16 @@ fn trajectory_labels_agree_with_tool_failure_counts() {
let session = request(vec![
Message::text(Role::User, "check the task"),
call("c1"),
- Message {
- role: Role::Tool,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::Tool,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "c1".into(),
content: vec![ContentBlock::Text {
text: output.into(),
}],
is_error,
})],
- },
+ ),
]);
let caps = derive_capabilities(&session, "checked", Some(TaskType::Agentic));
assert_eq!(caps.tools.unwrap().errors, i32::from(failed), "{output}");
diff --git a/crates/libsy/src/algorithms/vgr/text.rs b/crates/libsy/src/algorithms/vgr/text.rs
index aea174707..c4485157e 100644
--- a/crates/libsy/src/algorithms/vgr/text.rs
+++ b/crates/libsy/src/algorithms/vgr/text.rs
@@ -78,7 +78,7 @@ pub(super) fn turns(request: &Request) -> (Vec<Turn>, bool) {
for InstructionBlock { role, content } in &request.llm_request.instructions {
push(*role, content);
}
- for Message { role, content } in &request.llm_request.messages {
+ for Message { role, content, .. } in &request.llm_request.messages {
push(*role, content);
}
(flattened, unsupported)
diff --git a/crates/prefill-router/tests/unit/algorithm.rs b/crates/prefill-router/tests/unit/algorithm.rs
index 2aad5fc7c..6aa541174 100644
--- a/crates/prefill-router/tests/unit/algorithm.rs
+++ b/crates/prefill-router/tests/unit/algorithm.rs
@@ -182,16 +182,16 @@ async fn tool_result_after_the_person_is_walked_past_not_skipped() -> libsy::Res
request(vec![
Message::text(Role::User, "follow-up task"),
Message::text(Role::Assistant, "calling a tool"),
- Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "call-1".to_string(),
content: vec![ContentBlock::Text {
text: "tool output".to_string(),
}],
is_error: None,
})],
- },
+ ),
]),
)
.await?;
@@ -235,16 +235,16 @@ async fn routes_on_latest_user_text_and_reuses_decision_for_tool_steps() -> libs
Message::text(Role::Assistant, "working"),
Message::text(Role::User, "follow-up task"),
Message::text(Role::Assistant, "calling a tool"),
- Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id: "call-1".to_string(),
content: vec![ContentBlock::Text {
text: "tool output".to_string(),
}],
is_error: None,
})],
- },
+ ),
]),
)
.await?;
diff --git a/crates/protocol/README.md b/crates/protocol/README.md
index 83a1eff17..aa71eab2c 100644
--- a/crates/protocol/README.md
+++ b/crates/protocol/README.md
@@ -31,12 +31,12 @@ use switchyard_protocol::{ContentBlock, LlmRequest, Message, Role};
let request = LlmRequest {
model: Some("provider/model".into()),
- messages: vec![Message {
- role: Role::User,
- content: vec![ContentBlock::Text {
+ messages: vec![Message::new(
+ Role::User,
+ vec![ContentBlock::Text {
text: "Explain tail latency".into(),
}],
- }],
+ )],
..LlmRequest::default()
};
diff --git a/crates/protocol/src/llm.rs b/crates/protocol/src/llm.rs
index edcf87689..1e4e6e9c3 100644
--- a/crates/protocol/src/llm.rs
+++ b/crates/protocol/src/llm.rs
@@ -48,17 +48,26 @@ pub struct Message {
pub role: Role,
/// Ordered message content.
pub content: Vec<ContentBlock>,
+ /// OpenAI Responses assistant message `phase`, such as `commentary` or `final_answer`.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub phase: Option<String>,
}
impl Message {
- /// Creates a text-only message for the given role.
- pub fn text(role: Role, text: impl Into<String>) -> Self {
+ /// Creates a message with no `phase`.
+ pub fn new(role: Role, content: Vec<ContentBlock>) -> Self {
Self {
role,
- content: vec![ContentBlock::Text { text: text.into() }],
+ content,
+ phase: None,
}
}
+ /// Creates a text-only message for the given role.
+ pub fn text(role: Role, text: impl Into<String>) -> Self {
+ Self::new(role, vec![ContentBlock::Text { text: text.into() }])
+ }
+
/// Concatenates text-like content blocks when the message has any.
pub fn text_content(&self, separator: &str) -> Option<String> {
let parts = self
diff --git a/crates/switchyard-translation/src/codecs/anthropic/buffered.rs b/crates/switchyard-translation/src/codecs/anthropic/buffered.rs
index ec7552a36..5639f1765 100644
--- a/crates/switchyard-translation/src/codecs/anthropic/buffered.rs
+++ b/crates/switchyard-translation/src/codecs/anthropic/buffered.rs
@@ -151,7 +151,7 @@ impl FormatCodec for AnthropicMessagesCodec {
&mut diagnostics,
policy,
)?;
- request.messages.push(Message { role, content });
+ request.messages.push(Message::new(role, content));
}
}
request.tools = decode_anthropic_tools(body.get("tools"));
diff --git a/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs b/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs
index fdf2ef30e..a6af1d8eb 100644
--- a/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs
+++ b/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs
@@ -135,14 +135,14 @@ impl FormatCodec for OpenAiChatCodec {
.and_then(Value::as_str)
.unwrap_or_default()
.to_string();
- request.messages.push(Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ request.messages.push(Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
tool_call_id,
content: vec![ContentBlock::Text { text }],
is_error: message.get("is_error").and_then(Value::as_bool),
})],
- });
+ ));
continue;
}
match role {
@@ -152,7 +152,7 @@ impl FormatCodec for OpenAiChatCodec {
.push(InstructionBlock { role, content });
}
Role::User | Role::Assistant | Role::Tool => {
- request.messages.push(Message { role, content });
+ request.messages.push(Message::new(role, content));
}
}
}
@@ -899,10 +899,7 @@ fn push_pending_openai_message(
return Ok(());
}
- let message = Message {
- role,
- content: std::mem::take(pending_content),
- };
+ let message = Message::new(role, std::mem::take(pending_content));
out.push(encode_message_without_tool_results_to_openai(
&message,
diagnostics,
diff --git a/crates/switchyard-translation/src/codecs/responses/buffered.rs b/crates/switchyard-translation/src/codecs/responses/buffered.rs
index 45b7c5aae..2a0acc6ca 100644
--- a/crates/switchyard-translation/src/codecs/responses/buffered.rs
+++ b/crates/switchyard-translation/src/codecs/responses/buffered.rs
@@ -526,7 +526,7 @@ fn decode_responses_input(
&& pending_tool_outputs.is_empty()
&& pending_reasoning.is_empty())
{
- deferred_messages.push(Message { role, content });
+ deferred_messages.push(Message::new(role, content));
continue;
}
// Reasoning that precedes an assistant message belongs to
@@ -559,7 +559,15 @@ fn decode_responses_input(
&mut pending_tool_outputs,
&mut deferred_messages,
&mut pending_reasoning,
- Message { role, content },
+ Message {
+ role,
+ content,
+ phase: if role == Role::Assistant {
+ item.get("phase").and_then(Value::as_str).map(str::to_owned)
+ } else {
+ None
+ },
+ },
);
}
Some("reasoning") => {
@@ -720,8 +728,8 @@ fn decode_responses_input(
// decoder and re-emitted in place by the request encoder.
Some("additional_tools") => {}
_ => {
- let message = Message {
- role: match item_type {
+ let message = Message::new(
+ match item_type {
Some(
"shell_call"
| "apply_patch_call"
@@ -735,11 +743,11 @@ fn decode_responses_input(
) => Role::Tool,
_ => Role::User,
},
- content: vec![ContentBlock::Unknown {
+ vec![ContentBlock::Unknown {
provider: WireFormat::OpenAiResponses.into(),
raw: Value::Object(item.clone()),
}],
- };
+ );
flush_unattached_responses_reasoning(
&mut messages,
&mut pending_tool_calls,
@@ -770,10 +778,7 @@ fn decode_responses_input(
// Trailing reasoning with no assistant turn to join keeps the
// historical standalone-message shape.
if !pending_reasoning.is_empty() {
- messages.push(Message {
- role: Role::Assistant,
- content: pending_reasoning,
- });
+ messages.push(Message::new(Role::Assistant, pending_reasoning));
}
messages.append(&mut deferred_messages);
Ok(messages)
@@ -823,10 +828,7 @@ fn flush_unattached_responses_reasoning(
if pending_reasoning.is_empty() || !pending_tool_calls.is_empty() {
return;
}
- let message = Message {
- role: Role::Assistant,
- content: std::mem::take(pending_reasoning),
- };
+ let message = Message::new(Role::Assistant, std::mem::take(pending_reasoning));
push_responses_non_tool_message(
messages,
pending_tool_calls,
@@ -856,17 +858,14 @@ fn flush_responses_tool_block(
.into_iter()
.map(ContentBlock::ToolCall),
);
- messages.push(Message {
- role: Role::Assistant,
- content,
- });
+ messages.push(Message::new(Role::Assistant, content));
}
for output in std::mem::take(pending_tool_outputs) {
- messages.push(Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(output)],
- });
+ messages.push(Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(output)],
+ ));
}
messages.append(deferred_messages);
@@ -1339,11 +1338,7 @@ fn encode_responses_input(
if !visible_content.is_empty() {
let content =
encode_responses_content(&visible_content, diagnostics, policy)?;
- encoded.push(json!({
- "type": "message",
- "role": role_to_responses(message.role),
- "content": content,
- }));
+ encoded.push(encode_responses_message(message, content));
visible_content.clear();
}
encoded.push(item);
@@ -1353,11 +1348,7 @@ fn encode_responses_input(
}
if !visible_content.is_empty() {
let content = encode_responses_content(&visible_content, diagnostics, policy)?;
- encoded.push(json!({
- "type": "message",
- "role": role_to_responses(message.role),
- "content": content,
- }));
+ encoded.push(encode_responses_message(message, content));
}
continue;
}
@@ -1382,19 +1373,31 @@ fn encode_responses_input(
omitted_reasoning = true;
}
}
- if !visible_content.is_empty() || (!emitted_special && !omitted_reasoning) {
+ if !visible_content.is_empty()
+ || (!emitted_special && !omitted_reasoning)
+ || (message.role == Role::Assistant && message.phase.is_some())
+ {
let content = encode_responses_content(&visible_content, diagnostics, policy)?;
- encoded.push(json!({
- "type": "message",
- "role": role_to_responses(message.role),
- "content": content,
- }));
+ encoded.push(encode_responses_message(message, content));
}
}
pair_tool_calls_with_outputs(&mut encoded);
Ok(Value::Array(encoded))
}
+// Responses defines `phase` only on assistant message items, so drop it elsewhere.
+fn encode_responses_message(message: &Message, content: Value) -> Value {
+ let mut item = json!({
+ "type": "message",
+ "role": role_to_responses(message.role),
+ "content": content,
+ });
+ if let (Role::Assistant, Some(phase)) = (message.role, &message.phase) {
+ item["phase"] = json!(phase);
+ }
+ item
+}
+
// Moves each tool output directly behind the call it answers. A turn with
// parallel tool calls otherwise serializes as call,call,output,output, which
// upstreams that pair by adjacency (Kimi K3) resolve to the wrong call.
diff --git a/crates/switchyard-translation/tests/capability_policy.rs b/crates/switchyard-translation/tests/capability_policy.rs
index acd163e79..b19377ccd 100644
--- a/crates/switchyard-translation/tests/capability_policy.rs
+++ b/crates/switchyard-translation/tests/capability_policy.rs
@@ -71,10 +71,9 @@ fn request_for(case: CapabilityCase) -> LlmRequest {
}
};
if let Some(content) = content {
- request.messages.push(Message {
- role: Role::User,
- content: vec![content],
- });
+ request
+ .messages
+ .push(Message::new(Role::User, vec![content]));
}
request
}
diff --git a/crates/switchyard-translation/tests/request_translation.rs b/crates/switchyard-translation/tests/request_translation.rs
index 13fe756d1..72e78a451 100644
--- a/crates/switchyard-translation/tests/request_translation.rs
+++ b/crates/switchyard-translation/tests/request_translation.rs
@@ -17,6 +17,73 @@ use common::{REASONING_MODEL, normalized_policy, shell_tool_call};
type TestResult<T = ()> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
+#[test]
+fn responses_assistant_phase_survives_rebuilds() -> TestResult {
+ let engine = TranslationEngine::default();
+ let policy = TranslationPolicy::default();
+ for phase in [Some("commentary"), Some("final_answer"), None] {
+ let mut message = json!({"type": "message", "role": "assistant", "content": "Done."});
+ if let Some(phase) = phase {
+ message["phase"] = json!(phase);
+ }
+ let body = json!({"model": "route", "input": [message]});
+ let mut request = engine
+ .decode_request(WireFormat::OpenAiResponses, &body, &policy)?
+ .request;
+ // Force a rebuild with an unrelated edit.
+ request.preservation.requests.clear();
+ switchyard_translation::append_note(&mut request, "Check the result.");
+ request.model = Some("target".into());
+
+ let output = engine.encode_request(WireFormat::OpenAiResponses, &request, &policy)?;
+ assert_eq!(output.body["input"][0].get("phase"), message.get("phase"));
+ assert_eq!(output.body["input"].as_array().map(Vec::len), Some(2));
+ assert_eq!(output.body["model"], "target");
+ }
+ Ok(())
+}
+
+#[test]
+fn responses_assistant_phase_is_dropped_for_other_formats() -> TestResult {
+ let engine = TranslationEngine::default();
+ let strict = TranslationPolicy {
+ lossy_conversion_policy: LossyConversionPolicy::Reject,
+ ..normalized_policy()
+ };
+ let body = json!({
+ "model": "route",
+ "input": [{"type": "message", "role": "assistant", "phase": "commentary", "content": "Done."}]
+ });
+ let request = engine
+ .decode_request(WireFormat::OpenAiResponses, &body, &strict)?
+ .request;
+ for target in [WireFormat::OpenAiChat, WireFormat::AnthropicMessages] {
+ let output = engine.encode_request(target, &request, &strict)?;
+ assert!(output.body["messages"][0].get("phase").is_none());
+ assert!(output.diagnostics.is_empty(), "{:?}", output.diagnostics);
+ }
+ Ok(())
+}
+
+#[test]
+fn responses_assistant_phase_survives_reasoning_only_turn() -> TestResult {
+ let engine = TranslationEngine::default();
+ let body = json!({
+ "model": "route",
+ "input": [
+ {"type": "reasoning", "summary": [{"type": "summary_text", "text": "thinking"}]},
+ {"type": "message", "role": "assistant", "phase": "commentary", "content": []}
+ ]
+ });
+ let request = engine
+ .decode_request(WireFormat::OpenAiResponses, &body, &normalized_policy())?
+ .request;
+ let output =
+ engine.encode_request(WireFormat::OpenAiResponses, &request, &normalized_policy())?;
+ assert_eq!(output.body["input"][1]["phase"], "commentary");
+ Ok(())
+}
+
#[test]
fn normalized_chat_requests_forward_logprobs_with_top_logprobs() -> TestResult {
let engine = TranslationEngine::default();
@@ -164,9 +231,9 @@ fn openai_chat_rejects_mcp_history_before_text_only_returns() {
let engine = TranslationEngine::default();
for role in [Role::User, Role::Assistant] {
let request = LlmRequest {
- messages: vec![Message {
+ messages: vec![Message::new(
role,
- content: vec![
+ vec![
ContentBlock::Text {
text: "Keep this text".into(),
},
@@ -177,7 +244,7 @@ fn openai_chat_rejects_mcp_history_before_text_only_returns() {
error: None,
}),
],
- }],
+ )],
..LlmRequest::default()
};
for lossy_conversion_policy in [
@@ -2151,10 +2218,9 @@ fn anthropic_reports_dropped_instruction_content() -> TestResult {
role: Role::System,
content: vec![text.clone(), image.clone()],
});
- inline.messages.push(Message {
- role: Role::Developer,
- content: vec![text, image],
- });
+ inline
+ .messages
+ .push(Message::new(Role::Developer, vec![text, image]));
let strict = TranslationPolicy {
lossy_conversion_policy: LossyConversionPolicy::Reject,
diff --git a/docs/getting_started.md b/docs/getting_started.md
index 01580f584..74d5cf98d 100644
--- a/docs/getting_started.md
+++ b/docs/getting_started.md
@@ -99,17 +99,17 @@ use switchyard_protocol::{ContentBlock, Message, Role, ToolCall, ToolResult};
let mut request = request;
// Describe the agent's past activity; this example does not execute bash.
request.llm_request.messages.extend([
- Message {
- role: Role::Assistant,
- content: vec![ContentBlock::ToolCall(ToolCall {
+ Message::new(
+ Role::Assistant,
+ vec![ContentBlock::ToolCall(ToolCall {
id: "c1".into(),
name: "bash".into(),
arguments: r#"{"command":"cargo test"}"#.parse()?,
})],
- },
- Message {
- role: Role::User,
- content: vec![ContentBlock::ToolResult(ToolResult {
+ ),
+ Message::new(
+ Role::User,
+ vec![ContentBlock::ToolResult(ToolResult {
// The result refers to the tool call above by its ID.
tool_call_id: "c1".into(),
is_error: Some(true),
@@ -117,7 +117,7 @@ request.llm_request.messages.extend([
text: "MemoryError: cannot allocate memory\nKilled".into(),
}],
})],
- },
+ ),
]);
```