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 inline System and Developer messages (#1244)

Graham King972001efddca
diff --git a/crates/libsy/src/algorithms/advisor_gate.rs b/crates/libsy/src/algorithms/advisor_gate.rs
index d44711e8d..91a9acc07 100644
--- a/crates/libsy/src/algorithms/advisor_gate.rs
+++ b/crates/libsy/src/algorithms/advisor_gate.rs
@@ -381,10 +381,11 @@ impl AdvisorGate {
review_tail: Option<&str>,
trigger: &'static str,
) -> Result<ConsultOutcome> {
- // The advisor reviews the FULL transcript: system/developer content is
- // normalized out of `messages` into `instructions`, so prepend it back
- // as leading messages (identical {role, content} shape) — the task
- // constraints the verdict must check against usually live there.
+ // The advisor reviews the FULL transcript. Top-level system/developer
+ // content lives in `instructions`, so prepend it as leading messages
+ // (identical {role, content} shape). The task constraints the verdict
+ // must check against usually live there. Inline instruction messages
+ // stay in place.
let transcript_messages: Vec<Message> = base
.llm_request
.instructions
diff --git a/crates/libsy/src/algorithms/llm_class.rs b/crates/libsy/src/algorithms/llm_class.rs
index de0b06e95..48486ca5f 100644
--- a/crates/libsy/src/algorithms/llm_class.rs
+++ b/crates/libsy/src/algorithms/llm_class.rs
@@ -95,8 +95,8 @@ impl TaskClassifierVerdict {
/// Keeps the opening task and the last `recent_turn_window` turns after it. A
/// window of `0` keeps the task alone.
///
-/// Inbound decoders normalize client system and developer content into
-/// `LlmRequest::instructions`, so it never reaches this list.
+/// Inline system and developer messages are kept, in their original order,
+/// ahead of the task.
///
/// Selects by reference and clones only what survives — a coding-agent
/// conversation carries every tool result, so cloning it whole to keep a window
diff --git a/crates/libsy/src/algorithms/util/affinity.rs b/crates/libsy/src/algorithms/util/affinity.rs
index b236cf876..a325d6aca 100644
--- a/crates/libsy/src/algorithms/util/affinity.rs
+++ b/crates/libsy/src/algorithms/util/affinity.rs
@@ -63,17 +63,23 @@ fn is_environment_context(block: &ContentBlock) -> bool {
.is_some_and(|(_, rest)| rest.trim().is_empty()))
}
-pub(crate) fn is_environment_update(message: &Message) -> bool {
+fn is_environment_update(message: &Message) -> bool {
message.role == Role::User
&& !message.content.is_empty()
&& message.content.iter().all(is_environment_context)
}
+/// Inline instructions and standalone Codex environment updates sit between turns.
+/// Turn detection skips them when it looks for the previous message.
+pub(crate) fn is_turn_context(message: &Message) -> bool {
+ matches!(message.role, Role::System | Role::Developer) || is_environment_update(message)
+}
+
pub(crate) fn has_new_user_turn(messages: &[Message]) -> bool {
messages
.iter()
.rev()
- .find(|message| !is_environment_update(message))
+ .find(|message| !is_turn_context(message))
.is_some_and(is_user_turn)
}
@@ -370,6 +376,8 @@ mod tests {
has_new_user_turn(&[
Message::text(role, "follow-up"),
Message::text(Role::User, context),
+ Message::text(Role::System, "System guidance"),
+ Message::text(Role::Developer, "Developer guidance"),
]),
expected
);
diff --git a/crates/libsy/src/algorithms/vgr/tests.rs b/crates/libsy/src/algorithms/vgr/tests.rs
index a0b43f4ac..dfbd6394f 100644
--- a/crates/libsy/src/algorithms/vgr/tests.rs
+++ b/crates/libsy/src/algorithms/vgr/tests.rs
@@ -78,6 +78,27 @@ fn tool_trajectory_respects_the_current_request_initiator() {
"finished={finished}, initiator={initiator:?}"
);
}
+ for role in [Role::System, Role::Developer] {
+ for (previous, expected) in [
+ (Message::text(Role::Assistant, "done"), true),
+ (call("c1"), false),
+ ] {
+ let request = request(vec![
+ Message::text(Role::User, "fix the build"),
+ previous,
+ Message::text(role, "Follow repository instructions"),
+ Message::text(Role::User, "verify the change"),
+ ]);
+ assert_eq!(
+ super::text::starts_user_turn(&request.llm_request.messages, 3),
+ expected
+ );
+ assert_eq!(
+ super::text::turn_start(&request),
+ if expected { 3 } else { 0 }
+ );
+ }
+ }
assert!(!super::text::turn_has_tool_trajectory(&Request::default()));
}
diff --git a/crates/libsy/src/algorithms/vgr/text.rs b/crates/libsy/src/algorithms/vgr/text.rs
index 6148a5b1a..aea174707 100644
--- a/crates/libsy/src/algorithms/vgr/text.rs
+++ b/crates/libsy/src/algorithms/vgr/text.rs
@@ -11,7 +11,7 @@ use regex::Regex;
use serde_json::Value;
use switchyard_protocol::{ContentBlock, InstructionBlock, Message, Request, Role, ToolResult};
-use crate::algorithms::util::affinity::{initiated_by_user, is_environment_update, is_user_turn};
+use crate::algorithms::util::affinity::{initiated_by_user, is_turn_context, is_user_turn};
use crate::algorithms::util::tool_signals::classify_text;
/// One flattened turn: instructions first, then messages.
@@ -132,7 +132,7 @@ pub(super) fn starts_user_turn(messages: &[Message], index: usize) -> bool {
previous
.iter()
.rev()
- .find(|message| !is_environment_update(message))
+ .find(|message| !is_turn_context(message))
}),
) else {
return false;
diff --git a/crates/switchyard-translation/src/codecs/anthropic/buffered.rs b/crates/switchyard-translation/src/codecs/anthropic/buffered.rs
index ca2f42587..ec7552a36 100644
--- a/crates/switchyard-translation/src/codecs/anthropic/buffered.rs
+++ b/crates/switchyard-translation/src/codecs/anthropic/buffered.rs
@@ -225,6 +225,13 @@ impl FormatCodec for AnthropicMessagesCodec {
.instructions
.iter()
.flat_map(|instruction| instruction.content.iter())
+ .chain(
+ request
+ .messages
+ .iter()
+ .filter(|message| matches!(message.role, Role::System | Role::Developer))
+ .flat_map(|message| message.content.iter()),
+ )
.filter_map(|block| match block {
ContentBlock::Text { text } | ContentBlock::Refusal { text } => Some(text.as_str()),
_ => None,
@@ -234,6 +241,34 @@ impl FormatCodec for AnthropicMessagesCodec {
if !system_text.is_empty() {
body.insert("system".to_string(), Value::String(system_text));
}
+ // Anthropic `system` is a text field, so other instruction content is dropped.
+ let instructions = request
+ .instructions
+ .iter()
+ .enumerate()
+ .map(|(index, block)| (block.role, &block.content, "instruction", index));
+ let inline = request
+ .messages
+ .iter()
+ .enumerate()
+ .filter(|(_, message)| matches!(message.role, Role::System | Role::Developer))
+ .map(|(index, message)| (message.role, &message.content, "message", index));
+ for (role, content, kind, index) in instructions.chain(inline) {
+ for block in content {
+ if !matches!(
+ block,
+ ContentBlock::Text { .. } | ContentBlock::Refusal { .. }
+ ) {
+ push_lossy(
+ &mut diagnostics,
+ policy,
+ format!(
+ "Anthropic system prompt accepts only text; dropped non-text content from {role} {kind} {index}"
+ ),
+ )?;
+ }
+ }
+ }
body.insert(
"messages".to_string(),
@@ -883,6 +918,11 @@ fn encode_anthropic_messages(
let mut index = 0;
while let Some(message) = messages.get(index) {
+ // Inline instructions are emitted in the top-level system field.
+ if matches!(message.role, Role::System | Role::Developer) {
+ index += 1;
+ continue;
+ }
if !message_is_tool_result_only(message) {
encoded.push(encode_anthropic_message(message, diagnostics, policy)?);
index += 1;
@@ -891,6 +931,10 @@ fn encode_anthropic_messages(
let mut content = Vec::new();
while let Some(tool_message) = messages.get(index) {
+ if matches!(tool_message.role, Role::System | Role::Developer) {
+ index += 1;
+ continue;
+ }
if !message_is_tool_result_only(tool_message) {
break;
}
diff --git a/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs b/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs
index 71877834e..fdf2ef30e 100644
--- a/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs
+++ b/crates/switchyard-translation/src/codecs/openai_chat/buffered.rs
@@ -918,9 +918,11 @@ fn encode_message_without_tool_results_to_openai(
policy: &TranslationPolicy,
) -> Result<Value> {
let role = match message.role {
+ Role::System => "system",
+ Role::Developer => "developer",
Role::Assistant => "assistant",
Role::Tool => "tool",
- _ => "user",
+ Role::User => "user",
};
let tool_calls = message
.content
diff --git a/crates/switchyard-translation/src/codecs/responses/buffered.rs b/crates/switchyard-translation/src/codecs/responses/buffered.rs
index 18b173891..45b7c5aae 100644
--- a/crates/switchyard-translation/src/codecs/responses/buffered.rs
+++ b/crates/switchyard-translation/src/codecs/responses/buffered.rs
@@ -24,9 +24,9 @@ use crate::diagnostic::TranslationDiagnostic;
use crate::error::{Result, TranslationError};
use crate::format::{FormatId, WireFormat};
use crate::llm::{
- AggLlmResponse, ContentBlock, FileSource, ImageSource, InstructionBlock, LlmRequest,
- MediaSource, Message, OutputParams, ProviderExtensions, ReasoningParams, ResponseOutput, Role,
- SamplingParams, StopReason, Tool, ToolCall, ToolChoice, ToolDefinition, ToolResult, Usage,
+ AggLlmResponse, ContentBlock, FileSource, ImageSource, LlmRequest, MediaSource, Message,
+ OutputParams, ProviderExtensions, ReasoningParams, ResponseOutput, Role, SamplingParams,
+ StopReason, Tool, ToolCall, ToolChoice, ToolDefinition, ToolResult, Usage,
};
use crate::policy::{DeterministicIdPolicy, TranslationPolicy};
use crate::util::{
@@ -97,15 +97,13 @@ impl FormatCodec for OpenAiResponsesCodec {
.and_then(Value::as_str)
.is_some_and(|id| !id.is_empty());
let mut custom_call_outputs = Vec::new();
- let (messages, instructions) = decode_responses_input(
+ request.messages = decode_responses_input(
body.get("input").unwrap_or(&Value::String(String::new())),
stored_state,
&mut custom_call_outputs,
&mut diagnostics,
policy,
)?;
- request.messages = messages;
- request.instructions.extend(instructions);
let mut tool_namespaces = Map::new();
let mut custom_tools = Map::new();
request.tools =
@@ -457,25 +455,18 @@ impl FormatCodec for OpenAiResponsesCodec {
}
}
-/// Decodes Responses `input` into ordered normalized messages and inline
-/// instruction blocks.
-///
-/// Inline `system` and `developer` message items are returned as instruction
-/// blocks rather than conversation turns. Classifying them here, before any
-/// reasoning or tool-call state-machine transitions, prevents an instruction
-/// item from flushing pending reasoning or disturbing tool-call grouping.
+/// Decodes Responses `input` into ordered normalized messages.
fn decode_responses_input(
value: &Value,
stored_state: bool,
custom_call_outputs: &mut Vec<String>,
diagnostics: &mut Vec<TranslationDiagnostic>,
policy: &TranslationPolicy,
-) -> Result<(Vec<Message>, Vec<InstructionBlock>)> {
+) -> Result<Vec<Message>> {
match value {
- Value::String(text) => Ok((vec![Message::text(Role::User, text)], Vec::new())),
+ Value::String(text) => Ok(vec![Message::text(Role::User, text)]),
Value::Array(items) => {
let mut messages = Vec::new();
- let mut instructions = Vec::new();
let mut pending_tool_calls = Vec::new();
let mut pending_tool_outputs = Vec::new();
let mut deferred_messages = Vec::new();
@@ -526,16 +517,18 @@ fn decode_responses_input(
.to_string(),
});
}
- let content = decode_responses_content(content_value);
- // Inline system and developer input items are instructions, not
- // conversation turns. Classify them before any state-machine
- // transitions so they do not flush pending reasoning or disturb
- // tool-call grouping.
- if matches!(role, Role::System | Role::Developer) {
- instructions.push(InstructionBlock { role, content });
+ let mut content = decode_responses_content(content_value);
+ // Inline instructions wait behind an open tool block or pending
+ // reasoning. They never split tool calls from their outputs, and
+ // reasoning keeps its place before them.
+ if matches!(role, Role::System | Role::Developer)
+ && !(pending_tool_calls.is_empty()
+ && pending_tool_outputs.is_empty()
+ && pending_reasoning.is_empty())
+ {
+ deferred_messages.push(Message { role, content });
continue;
}
- let mut content = content;
// Reasoning that precedes an assistant message belongs to
// that turn; fold it in so it never surfaces as its own
// (empty-looking) assistant message downstream.
@@ -546,6 +539,10 @@ fn decode_responses_input(
let mut merged = std::mem::take(&mut pending_reasoning);
merged.append(&mut content);
content = merged;
+ // Instructions held behind the reasoning came before this turn.
+ if pending_tool_outputs.is_empty() {
+ messages.append(&mut deferred_messages);
+ }
}
if role != Role::Assistant {
flush_unattached_responses_reasoning(
@@ -778,7 +775,8 @@ fn decode_responses_input(
content: pending_reasoning,
});
}
- Ok((messages, instructions))
+ messages.append(&mut deferred_messages);
+ Ok(messages)
}
_ => Err(TranslationError::InvalidType {
path: "$.input".to_string(),
@@ -837,6 +835,8 @@ fn flush_unattached_responses_reasoning(
pending_reasoning,
message,
);
+ // Instructions held behind the reasoning follow it.
+ messages.append(deferred_messages);
}
/// Flushes pending function calls and matching outputs while preserving adjacency.
diff --git a/crates/switchyard-translation/src/compaction.rs b/crates/switchyard-translation/src/compaction.rs
index d45bf54e6..6091504cb 100644
--- a/crates/switchyard-translation/src/compaction.rs
+++ b/crates/switchyard-translation/src/compaction.rs
@@ -26,7 +26,10 @@ pub fn normalize_compaction(request: &mut LlmRequest, headers: Option<&HeaderMap
.messages
.iter()
.rev()
- .find(|message| !is_environment_update(message))
+ .find(|message| {
+ !matches!(message.role, Role::System | Role::Developer)
+ && !is_environment_update(message)
+ })
.is_some_and(|message| message.role == Role::User && is_compaction_message(message));
}
@@ -115,6 +118,15 @@ mod tests {
]});
let request = decode_request(WireFormat::OpenAiChat, &body).unwrap();
assert!(request.is_compaction && request.has_compaction);
+ for role in [super::Role::System, super::Role::Developer] {
+ let mut with_instruction = request.clone();
+ with_instruction
+ .messages
+ .push(super::Message::text(role, "Follow repository instructions"));
+ with_instruction.is_compaction = false;
+ super::normalize_compaction(&mut with_instruction, None);
+ assert!(with_instruction.is_compaction);
+ }
body["messages"]
.as_array_mut()
.unwrap()
diff --git a/crates/switchyard-translation/tests/request_translation.rs b/crates/switchyard-translation/tests/request_translation.rs
index 07e3d3ec2..13fe756d1 100644
--- a/crates/switchyard-translation/tests/request_translation.rs
+++ b/crates/switchyard-translation/tests/request_translation.rs
@@ -8,8 +8,9 @@ pub mod common;
use pretty_assertions::assert_eq;
use serde_json::{Value, json};
use switchyard_translation::{
- ContentBlock, FormatId, LossyConversionPolicy, TranslationEngine, TranslationError,
- TranslationPolicy, WireFormat, prepare_request_for_target, sanitize_anthropic_tool_use_id,
+ ContentBlock, FormatId, ImageSource, InstructionBlock, LlmRequest, LossyConversionPolicy,
+ Message, Role, TranslationEngine, TranslationError, TranslationPolicy, WireFormat,
+ prepare_request_for_target, sanitize_anthropic_tool_use_id,
};
use common::{REASONING_MODEL, normalized_policy, shell_tool_call};
@@ -2068,6 +2069,193 @@ fn responses_input_messages_translate_with_instruction_roles_intact() -> TestRes
Ok(())
}
+#[test]
+fn responses_rebuild_preserves_inline_instructions() -> TestResult {
+ let engine = TranslationEngine::default();
+ let policy = TranslationPolicy::default();
+ let body = json!({
+ "model": "gpt-4",
+ "instructions": "Top-level guidance.",
+ "input": [
+ {"type": "message", "role": "system", "content": "Initial system."},
+ {"type": "message", "role": "developer", "content": "Initial developer."},
+ {"type": "message", "role": "user", "content": "Hello."},
+ {"type": "message", "role": "system", "content": "Later system."},
+ {"type": "message", "role": "developer", "content": "Later developer."},
+ {"type": "message", "role": "developer", "content": "Separate message."},
+ {"type": "message", "role": "user", "content": "Original suffix."}
+ ]
+ });
+ let mut request = engine
+ .decode_request(WireFormat::OpenAiResponses, &body, &policy)?
+ .request;
+ request.preservation.requests.clear();
+ assert_eq!(
+ engine
+ .encode_request(WireFormat::OpenAiResponses, &request, &policy)?
+ .body,
+ body
+ );
+ let anthropic = engine
+ .encode_request(WireFormat::AnthropicMessages, &request, &policy)?
+ .body;
+ assert_eq!(
+ anthropic["system"],
+ "Top-level guidance.\n\nInitial system.\n\nInitial developer.\n\nLater system.\n\nLater developer.\n\nSeparate message."
+ );
+ assert_eq!(anthropic["messages"].as_array().map(Vec::len), Some(2));
+ request.messages.last_mut().ok_or("missing suffix")?.content = vec![ContentBlock::Text {
+ text: "Edited suffix.".into(),
+ }];
+ let expected = json!({
+ "model": "gpt-4",
+ "instructions": "Top-level guidance.",
+ "input": [
+ {"type": "message", "role": "system", "content": "Initial system."},
+ {"type": "message", "role": "developer", "content": "Initial developer."},
+ {"type": "message", "role": "user", "content": "Hello."},
+ {"type": "message", "role": "system", "content": "Later system."},
+ {"type": "message", "role": "developer", "content": "Later developer."},
+ {"type": "message", "role": "developer", "content": "Separate message."},
+ {"type": "message", "role": "user", "content": "Edited suffix."}
+ ]
+ });
+ assert_eq!(
+ engine
+ .encode_request(WireFormat::OpenAiResponses, &request, &policy)?
+ .body,
+ expected
+ );
+ Ok(())
+}
+
+// Anthropic `system` is text only, so non-text instruction content is lossy.
+#[test]
+fn anthropic_reports_dropped_instruction_content() -> TestResult {
+ let engine = TranslationEngine::default();
+ let image = ContentBlock::Image {
+ source: ImageSource::Url {
+ url: "https://example.test/layout.png".into(),
+ detail: None,
+ },
+ };
+ let text = ContentBlock::Text {
+ text: "Match this layout.".into(),
+ };
+ let mut top_level = LlmRequest {
+ messages: vec![Message::text(Role::User, "Hi")],
+ ..LlmRequest::default()
+ };
+ let mut inline = top_level.clone();
+ top_level.instructions.push(InstructionBlock {
+ role: Role::System,
+ content: vec![text.clone(), image.clone()],
+ });
+ inline.messages.push(Message {
+ role: Role::Developer,
+ content: vec![text, image],
+ });
+
+ let strict = TranslationPolicy {
+ lossy_conversion_policy: LossyConversionPolicy::Reject,
+ ..TranslationPolicy::default()
+ };
+ for (request, location) in [
+ (top_level, "system instruction 0"),
+ (inline, "developer message 1"),
+ ] {
+ let allowed = engine.encode_request(
+ WireFormat::AnthropicMessages,
+ &request,
+ &TranslationPolicy::default(),
+ )?;
+ assert_eq!(allowed.body["system"], "Match this layout.");
+ assert!(
+ allowed.diagnostics.iter().any(|diagnostic| {
+ diagnostic.code == "lossy_conversion" && diagnostic.message.contains(location)
+ }),
+ "{location}: {:?}",
+ allowed.diagnostics
+ );
+ assert!(matches!(
+ engine.encode_request(WireFormat::AnthropicMessages, &request, &strict),
+ Err(TranslationError::LossyConversion(_))
+ ));
+ }
+ Ok(())
+}
+
+// An inline instruction between parallel tool outputs moves after the tool block.
+#[test]
+fn responses_inline_instruction_inside_tool_block_follows_the_block() -> TestResult {
+ let engine = TranslationEngine::default();
+ let policy = TranslationPolicy::default();
+ let body = json!({
+ "model": "gpt-4",
+ "input": [
+ {"type": "message", "role": "user", "content": "Hi"},
+ {"type": "function_call", "call_id": "c1", "name": "f", "arguments": "{}"},
+ {"type": "function_call", "call_id": "c2", "name": "f", "arguments": "{}"},
+ {"type": "function_call_output", "call_id": "c1", "output": "one"},
+ {"type": "message", "role": "developer", "content": "Mid."},
+ {"type": "function_call_output", "call_id": "c2", "output": "two"},
+ {"type": "message", "role": "user", "content": "Next"}
+ ]
+ });
+ let mut request = engine
+ .decode_request(WireFormat::OpenAiResponses, &body, &policy)?
+ .request;
+ request.preservation.requests.clear();
+
+ let chat = engine
+ .encode_request(WireFormat::OpenAiChat, &request, &policy)?
+ .body;
+ assert_eq!(
+ chat["messages"],
+ json!([
+ {"role": "user", "content": "Hi"},
+ {"role": "assistant", "content": null, "tool_calls": [
+ {"id": "c1", "type": "function", "function": {"name": "f", "arguments": "{}"}},
+ {"id": "c2", "type": "function", "function": {"name": "f", "arguments": "{}"}}
+ ]},
+ {"role": "tool", "tool_call_id": "c1", "content": "one"},
+ {"role": "tool", "tool_call_id": "c2", "content": "two"},
+ {"role": "developer", "content": "Mid."},
+ {"role": "user", "content": "Next"}
+ ])
+ );
+
+ let responses = engine
+ .encode_request(WireFormat::OpenAiResponses, &request, &policy)?
+ .body;
+ let items = responses["input"].as_array().ok_or("missing input")?;
+ let shape: Vec<(&str, &str)> = items
+ .iter()
+ .map(|item| {
+ (
+ item["type"].as_str().unwrap_or_default(),
+ item["call_id"]
+ .as_str()
+ .or_else(|| item["role"].as_str())
+ .unwrap_or_default(),
+ )
+ })
+ .collect();
+ assert_eq!(
+ shape,
+ [
+ ("message", "user"),
+ ("function_call", "c1"),
+ ("function_call_output", "c1"),
+ ("function_call", "c2"),
+ ("function_call_output", "c2"),
+ ("message", "developer"),
+ ("message", "user"),
+ ]
+ );
+ Ok(())
+}
+
// Inline instruction items must not detach pending reasoning from the assistant
// turn that produced it.
#[test]
@@ -2099,6 +2287,43 @@ fn responses_inline_instruction_does_not_detach_reasoning() -> TestResult {
Ok(())
}
+// Standalone reasoning keeps its place before a later inline instruction.
+#[test]
+fn responses_standalone_reasoning_stays_before_inline_instruction() -> TestResult {
+ let engine = TranslationEngine::default();
+ let reasoning = json!({"type": "reasoning", "content": [{"type": "reasoning_text", "text": "thinking..."}], "summary": []});
+ let developer = json!({"type": "message", "role": "developer", "content": "Be terse."});
+ let user = json!({"type": "message", "role": "user", "content": "Next"});
+ for (input, expected) in [
+ (
+ json!([reasoning, developer, user]),
+ json!([
+ {"role": "assistant", "content": "", "reasoning": "thinking..."},
+ {"role": "developer", "content": "Be terse."},
+ {"role": "user", "content": "Next"}
+ ]),
+ ),
+ (
+ json!([reasoning, developer]),
+ json!([
+ {"role": "assistant", "content": "", "reasoning": "thinking..."},
+ {"role": "developer", "content": "Be terse."}
+ ]),
+ ),
+ ] {
+ let output = engine
+ .translate_request(
+ WireFormat::OpenAiResponses,
+ WireFormat::OpenAiChat,
+ &json!({"model": "gpt-4", "input": input}),
+ &TranslationPolicy::default(),
+ )?
+ .body;
+ assert_eq!(output["messages"], expected);
+ }
+ Ok(())
+}
+
// A discriminator-less object that is not message-shaped must not silently become prompt text.
#[test]
fn responses_input_without_type_or_message_shape_is_rejected() {
@@ -3605,6 +3830,23 @@ fn openai_tool_results_are_merged_when_translating_to_anthropic() -> TestResult
{"type": "tool_result", "tool_use_id": "call_2", "content": "two"}
])
);
+ let policy = TranslationPolicy::default();
+ let mut request = engine
+ .decode_request(WireFormat::OpenAiChat, &body, &policy)?
+ .request;
+ for role in [Role::System, Role::Developer] {
+ request
+ .messages
+ .insert(3, Message::text(role, "Keep results together."));
+ }
+ let with_instructions = engine
+ .encode_request(WireFormat::AnthropicMessages, &request, &policy)?
+ .body;
+ assert_eq!(with_instructions["messages"], output["messages"]);
+ assert_eq!(
+ with_instructions["system"],
+ "Keep results together.\n\nKeep results together."
+ );
Ok(())
}
diff --git a/docs/reference/protocols/llm_requests.md b/docs/reference/protocols/llm_requests.md
index 9c552e755..d64ecb734 100644
--- a/docs/reference/protocols/llm_requests.md
+++ b/docs/reference/protocols/llm_requests.md
@@ -27,8 +27,8 @@ the destination model. Select a Rust field or type for its full crate definition
| Protocol field and type | Meaning | Anthropic Messages | OpenAI Responses | Chat Completions |
|---|---|---|---|---|
| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.model"><code>LlmRequest.model: Option&lt;String&gt;</code></a> | Addressed model; the host can replace it with the selected target. | `model` | `model` | `model` |
-| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.instructions"><code>LlmRequest.instructions: Vec&lt;InstructionBlock&gt;</code></a> | System and developer instructions. | Top-level `system`; no distinct developer authority | `instructions` and system/developer messages in `input` | System/developer messages in `messages` |
-| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.messages"><code>LlmRequest.messages: Vec&lt;Message&gt;</code></a> | Ordered turns, each with a role and content blocks. | `messages[]` | Messages and tool items in `input` | `messages[]` |
+| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.instructions"><code>LlmRequest.instructions: Vec&lt;InstructionBlock&gt;</code></a> | Top-level system and developer instructions. | Top-level `system`; no distinct developer authority | `instructions` | System/developer messages in `messages` |
+| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.messages"><code>LlmRequest.messages: Vec&lt;Message&gt;</code></a> | Ordered turns, each with a role and content blocks. | `messages[]`; inline system/developer messages are added to top-level `system` on encode | Messages, including system/developer messages, and tool items in `input` | `messages[]` |
| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.tools"><code>LlmRequest.tools: Vec&lt;Tool&gt;</code></a> | Available functions, MCP toolsets, or retained provider definitions. | `tools[]` | `tools[]` | `tools[]`; function definitions are nested in `function` |
| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.tool_choice"><code>LlmRequest.tool_choice: Option&lt;ToolChoice&gt;</code></a> | Let the model choose, require a call, forbid calls, or select a named tool. | `auto`, `any`, `none`, or `tool` | `auto`, `required`, `none`, or `function` | `auto`, `required`, `none`, or `function` |
| <a href="../../../rust/switchyard_protocol/llm/struct.LlmRequest.html#structfield.stream"><code>LlmRequest.stream: bool</code></a> | Request incremental output. | `stream` | `stream` | `stream` |