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): replay responses reasoning as input history (#645)
sabhatinase19a91dd48c0
diff --git a/crates/libsy-llm-client/src/client.rs b/crates/libsy-llm-client/src/client.rsindex 371fc586f..de7f2ca6c 100644--- a/crates/libsy-llm-client/src/client.rs+++ b/crates/libsy-llm-client/src/client.rs@@ -246,6 +246,9 @@ impl TranslatingLlmClient {// which keeps the caller's original `model`; force the resolved model so// the upstream always sees the target id.set_json_model(&mut body, model);+ if matches!(backend, Backend::OpenAiResponses(_)) {+ sanitize_openai_responses_provider_body(&mut body);+ }// Strip before `merge_extra_body` so a target can reinstate either field// deliberately via `extra_body`.if matches!(backend, Backend::Anthropic(_)) {@@ -754,6 +757,124 @@ fn set_json_model(body: &mut Value, model: &str) {}}+const CODEX_NAMESPACE_SEPARATOR: &str = "__";++// Codex extends Responses with namespace containers and namespaced function+// calls. OpenAI-compatible providers expect a flat Responses tool namespace.+fn sanitize_openai_responses_provider_body(body: &mut Value) {+ let Value::Object(object) = body else {+ return;+ };+ sanitize_openai_responses_input_for_provider(object.get_mut("input"));+ sanitize_openai_responses_tools_for_provider(object.get_mut("tools"));+ sanitize_openai_responses_tool_choice_for_provider(object.get_mut("tool_choice"));+}++fn sanitize_openai_responses_input_for_provider(input: Option<&mut Value>) {+ let Some(Value::Array(items)) = input else {+ return;+ };+ for item in items {+ let Some(object) = item.as_object_mut() else {+ continue;+ };+ if object.get("type").and_then(Value::as_str) == Some("function_call") {+ qualify_responses_function_name(object);+ }+ }+}++fn sanitize_openai_responses_tools_for_provider(tools: Option<&mut Value>) {+ let Some(Value::Array(tools)) = tools else {+ return;+ };+ let mut flat_tools = Vec::with_capacity(tools.len());+ for tool in std::mem::take(tools) {+ push_sanitized_openai_responses_tool(&mut flat_tools, tool);+ }+ *tools = flat_tools;+}++fn push_sanitized_openai_responses_tool(out: &mut Vec<Value>, tool: Value) {+ let Value::Object(mut object) = tool else {+ out.push(tool);+ return;+ };+ if object.get("type").and_then(Value::as_str) == Some("namespace") {+ let namespace = object+ .get("name")+ .and_then(Value::as_str)+ .unwrap_or_default()+ .to_string();+ let Some(Value::Array(children)) = object.remove("tools") else {+ out.push(Value::Object(object));+ return;+ };+ for child in children {+ push_sanitized_namespaced_tool(out, &namespace, child);+ }+ return;+ }+ ensure_responses_function_tool_description(&mut object);+ out.push(Value::Object(object));+}++fn push_sanitized_namespaced_tool(out: &mut Vec<Value>, namespace: &str, tool: Value) {+ let Value::Object(mut object) = tool else {+ out.push(tool);+ return;+ };+ if object.get("type").and_then(Value::as_str) == Some("function") {+ qualify_responses_function_name_with_namespace(&mut object, namespace);+ ensure_responses_function_tool_description(&mut object);+ }+ out.push(Value::Object(object));+}++fn sanitize_openai_responses_tool_choice_for_provider(tool_choice: Option<&mut Value>) {+ let Some(Value::Object(object)) = tool_choice else {+ return;+ };+ if object.get("type").and_then(Value::as_str) == Some("function") {+ qualify_responses_function_name(object);+ }+}++fn qualify_responses_function_name(object: &mut Map<String, Value>) {+ let namespace = object+ .remove("namespace")+ .and_then(|value| value.as_str().map(ToOwned::to_owned));+ let Some(namespace) = namespace.as_deref() else {+ return;+ };+ qualify_responses_function_name_with_namespace(object, namespace);+}++fn qualify_responses_function_name_with_namespace(+ object: &mut Map<String, Value>,+ namespace: &str,+) {+ if namespace.is_empty() {+ return;+ }+ let Some(name) = object.get("name").and_then(Value::as_str) else {+ return;+ };+ let prefix = format!("{namespace}{CODEX_NAMESPACE_SEPARATOR}");+ if name.starts_with(&prefix) {+ return;+ }+ object.insert("name".to_string(), Value::String(format!("{prefix}{name}")));+}++fn ensure_responses_function_tool_description(object: &mut Map<String, Value>) {+ if object.get("type").and_then(Value::as_str) == Some("function")+ && !matches!(object.get("description"), Some(Value::String(_)))+ {+ object.insert("description".to_string(), Value::String(String::new()));+ }+}+// Drops fields accepted by OpenAI-like APIs but rejected by Anthropic Messages.//// A router can serve earlier turns of a session from an OpenAI-format target and@@ -957,6 +1078,14 @@ mod tests {)]}+ fn responses_map(base_url: &str) -> Vec<ModelConfig> {+ vec![ModelConfig::new(+ "gpt",+ Backend::OpenAiResponses(config(base_url)),+ None,+ )]+ }+fn chat_map_with_extra_body(base_url: &str,extra_body: BTreeMap<String, Value>,@@ -2190,6 +2319,99 @@ mod tests {Ok(())}+ #[tokio::test]+ async fn openai_responses_backend_flattens_codex_namespaces_before_upstream()+ -> std::result::Result<(), Box<dyn Error + Sync + Send + 'static>> {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path("/v1/responses"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "id": "resp_1",+ "model": "gpt",+ "object": "response",+ "created_at": 0,+ "status": "completed",+ "output": [{+ "type": "function_call",+ "call_id": "call_1",+ "name": "mcp__open_websearch__search",+ "arguments": "{\"q\":\"rust\"}"+ }],+ "usage": {"input_tokens": 1, "output_tokens": 1, "total_tokens": 2}+ })))+ .mount(&server)+ .await;++ let client = TranslatingLlmClient::new(&responses_map(&format!("{}/v1", server.uri())))?;+ let parameters = json!({"type": "object", "properties": {"q": {"type": "string"}}});+ let raw = json!({+ "model": "client-facing",+ "input": [{+ "type": "function_call",+ "call_id": "call_0",+ "name": "search",+ "namespace": "mcp__open_websearch",+ "arguments": "{}"+ }],+ "tool_choice": {+ "type": "function",+ "name": "search",+ "namespace": "mcp__open_websearch"+ },+ "tools": [{+ "type": "namespace",+ "name": "mcp__open_websearch",+ "tools": [{+ "type": "function",+ "name": "search",+ "parameters": parameters.clone()+ }]+ }]+ });++ let RawResponse::Buffered(body) = client+ .call_rewrite_model_raw(+ raw,+ None,+ Some(&ModelId::from("gpt")),+ WireFormat::OpenAiResponses,+ )+ .await?+ else {+ panic!("expected a buffered response");+ };++ let received = server+ .received_requests()+ .await+ .ok_or("request recording should be enabled")?;+ let request_body: Value = serde_json::from_slice(&received[0].body)?;+ assert_eq!(request_body["model"], "gpt");+ assert_eq!(+ request_body["tools"],+ json!([{+ "type": "function",+ "name": "mcp__open_websearch__search",+ "description": "",+ "parameters": parameters+ }])+ );+ assert_eq!(+ request_body["tool_choice"],+ json!({"type": "function", "name": "mcp__open_websearch__search"})+ );+ assert_eq!(+ request_body["input"][0]["name"],+ "mcp__open_websearch__search"+ );+ assert!(request_body["input"][0].get("namespace").is_none());++ assert_eq!(body["output"][0]["type"], "function_call");+ assert_eq!(body["output"][0]["name"], "search");+ assert_eq!(body["output"][0]["namespace"], "mcp__open_websearch");+ Ok(())+ }+// Raw path, streaming: an inbound `stream: true` request yields an unframed stream// of OpenAI Chat chunk objects whose deltas reassemble the completion.#[tokio::test]diff --git a/crates/switchyard-translation/src/codecs/responses/buffered.rs b/crates/switchyard-translation/src/codecs/responses/buffered.rsindex 03e11f15b..ff3d71cdf 100644--- a/crates/switchyard-translation/src/codecs/responses/buffered.rs+++ b/crates/switchyard-translation/src/codecs/responses/buffered.rs@@ -653,10 +653,17 @@ fn decode_responses_reasoning_item(item: &Map<String, Value>) -> Vec<ContentBlocif let Some(text) = item.get("text").and_then(Value::as_str) {parts.push(text.to_string());}+ // Encrypted reasoning must be replayed under the provider-issued item id;+ // retain the original item only when it carries that opaque payload.+ let details = if item.get("encrypted_content").is_some() {+ vec![Value::Object(item.clone())]+ } else {+ Vec::new()+ };vec![ContentBlock::Reasoning {text: parts.join("\n"),signature: None,- details: Vec::new(),+ details,}]}@@ -1060,15 +1067,18 @@ fn encode_responses_input(}let mut visible_content = Vec::new();let mut emitted_special = false;+ let mut omitted_reasoning = false;for block in &content {if let Some(item) = encode_responses_special_input(block, namespaces) {encoded.push(item);emitted_special = true;- } else {+ } else if !matches!(block, ContentBlock::Reasoning { .. }) {visible_content.push(block.clone());+ } else {+ omitted_reasoning = true;}}- if !visible_content.is_empty() || !emitted_special {+ if !visible_content.is_empty() || (!emitted_special && !omitted_reasoning) {let content = encode_responses_content(&visible_content, diagnostics, policy)?;encoded.push(json!({"type": "message",@@ -1089,12 +1099,8 @@ fn encode_responses_special_input(ContentBlock::Reasoning {text,signature: None,- ..- } => Some(json!({- "type": "reasoning",- "content": [{"type": "reasoning_text", "text": text}],- "summary": [],- })),+ details,+ } => encode_responses_reasoning_input(text, details),ContentBlock::ToolCall(call) => {// A Responses client dispatches on name plus namespace, so undo the// qualification this request applied for a flat upstream.@@ -1125,6 +1131,37 @@ fn encode_responses_special_input(}}+// Encodes reasoning in the shape accepted for Responses input history. Response+// output items may carry `content`, but replayed input items must avoid it.+fn encode_responses_reasoning_input(text: &str, details: &[Value]) -> Option<Value> {+ for detail in details {+ let Some(detail) = detail.as_object() else {+ continue;+ };+ if detail.get("type").and_then(Value::as_str) != Some("reasoning") {+ continue;+ }+ let mut item = Map::new();+ item.insert("type".to_string(), Value::String("reasoning".to_string()));+ for field in ["id", "summary", "encrypted_content"] {+ if let Some(value) = detail.get(field) {+ item.insert(field.to_string(), value.clone());+ }+ }+ item.entry("summary".to_string())+ .or_insert_with(|| Value::Array(Vec::new()));+ return Some(Value::Object(item));+ }++ if text.is_empty() {+ return None;+ }+ Some(json!({+ "type": "reasoning",+ "summary": [{"type": "summary_text", "text": text}],+ }))+}+// Maps normalized roles back to Responses role strings.fn role_to_responses(role: Role) -> &'static str {match role {diff --git a/crates/switchyard-translation/tests/request_translation.rs b/crates/switchyard-translation/tests/request_translation.rsindex d27b21cd9..d7169c8a0 100644--- a/crates/switchyard-translation/tests/request_translation.rs+++ b/crates/switchyard-translation/tests/request_translation.rs@@ -1436,13 +1436,108 @@ fn responses_reasoning_items_round_trip_through_decode_and_encode() -> TestResul]);assert_eq!(- input[1]["content"],- json!([{"type": "reasoning_text", "text": "Simple ls."}])+ input[1]["summary"],+ json!([{"type": "summary_text", "text": "Simple ls."}]));+ assert!(input[1].get("content").is_none());assert_eq!(input[2]["call_id"], "call-ls");Ok(())}+// Verifies Codex-style encrypted reasoning remains replayable after a prompt+// mutation drops exact replay, without synthesizing invalid reasoning content.+#[test]+fn responses_encrypted_reasoning_replays_without_input_content() -> TestResult {+ let engine = TranslationEngine::default();+ let body = json!({+ "model": "switchyard",+ "input": [+ {"type": "message", "role": "user", "content": "Inspect"},+ {+ "type": "reasoning",+ "id": "rs_prior",+ "summary": [],+ "encrypted_content": "opaque-encrypted-reasoning"+ },+ {+ "type": "function_call",+ "name": "exec_command",+ "call_id": "call-1",+ "arguments": "{\"cmd\":\"pwd\"}"+ },+ {"type": "function_call_output", "call_id": "call-1", "output": "/app"}+ ]+ });++ let policy = TranslationPolicy::default();+ let mut request = engine+ .decode_request(WireFormat::OpenAiResponses, &body, &policy)?+ .request;+ prepare_request_for_target(+ &mut request,+ &"openai/openai/gpt-5.6-sol".into(),+ Some("[router-guidance] Continue from the current state."),+ );++ let output = engine+ .encode_request(WireFormat::OpenAiResponses, &request, &policy)?+ .body;++ assert_eq!(output["model"], "openai/openai/gpt-5.6-sol");+ assert_eq!(+ output["instructions"],+ "[router-guidance] Continue from the current state."+ );+ let input = output["input"].as_array().ok_or("input is not an array")?;+ let reasoning = input+ .iter()+ .find(|item| item["type"] == "reasoning")+ .ok_or("reasoning item was not replayed")?;+ assert_eq!(reasoning["id"], "rs_prior");+ assert_eq!(reasoning["summary"], json!([]));+ assert_eq!(reasoning["encrypted_content"], "opaque-encrypted-reasoning");+ assert!(reasoning.get("content").is_none());+ Ok(())+}++// Verifies an empty non-encrypted reasoning item is omitted instead of being+// replayed as an empty assistant message.+#[test]+fn responses_empty_reasoning_without_encrypted_content_is_omitted() -> TestResult {+ let engine = TranslationEngine::default();+ let policy = TranslationPolicy {+ preservation: switchyard_translation::PreservationPolicy::Disabled,+ ..TranslationPolicy::default()+ };+ let body = json!({+ "model": "gpt-5",+ "input": [+ {"type": "message", "role": "user", "content": "Inspect"},+ {"type": "reasoning", "summary": []},+ {"type": "message", "role": "user", "content": "Continue"}+ ]+ });++ let output = engine+ .translate_request(+ WireFormat::OpenAiResponses,+ WireFormat::OpenAiResponses,+ &body,+ &policy,+ )?+ .body;++ let input = output["input"].as_array().ok_or("input is not an array")?;+ let item_types = input+ .iter()+ .map(|item| item["type"].as_str().unwrap_or_default())+ .collect::<Vec<_>>();+ assert_eq!(item_types, vec!["message", "message"]);+ assert_eq!(input[0]["role"], "user");+ assert_eq!(input[1]["role"], "user");+ Ok(())+}+// Verifies Responses JSON schema text format maps to Chat response_format shape.#[test]fn responses_json_schema_text_format_maps_to_chat_response_format() -> TestResult {