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.rsindex 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.instructionsdiff --git a/crates/libsy/src/algorithms/llm_class.rs b/crates/libsy/src/algorithms/llm_class.rsindex 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 windowdiff --git a/crates/libsy/src/algorithms/util/affinity.rs b/crates/libsy/src/algorithms/util/affinity.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.contentdiff --git a/crates/switchyard-translation/src/codecs/responses/buffered.rs b/crates/switchyard-translation/src/codecs/responses/buffered.rsindex 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.rsindex 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.rsindex 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() -> TestResOk(())}+#[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.mdindex 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<String></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<InstructionBlock></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<Message></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<InstructionBlock></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<Message></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<Tool></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<ToolChoice></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` |