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 buffered Responses output (#284)

nachiketb-nvidia0e99eb4d598e
diff --git a/crates/switchyard-translation/src/codecs/responses/buffered.rs b/crates/switchyard-translation/src/codecs/responses/buffered.rs
index b8aa9a4fd..466590913 100644
--- a/crates/switchyard-translation/src/codecs/responses/buffered.rs
+++ b/crates/switchyard-translation/src/codecs/responses/buffered.rs
@@ -182,24 +182,38 @@ impl FormatCodec for OpenAiResponsesCodec {
fn decode_response(&self, body: &Value, policy: &TranslationPolicy) -> Result<DecodedResponse> {
let body = crate::util::object(body, "$")?;
let mut diagnostics = Vec::new();
- let mut outputs = Vec::new();
+ let mut content = Vec::new();
+ let mut role = Role::Assistant;
+ let mut stop_reason = None;
+ let mut has_output = false;
if let Some(items) = body.get("output").and_then(Value::as_array) {
for item in items {
if let Some(output) = decode_responses_output_item(item, &mut diagnostics, policy)?
{
- outputs.push(output);
+ has_output = true;
+ role = output.role;
+ content.extend(output.content);
+ if output.stop_reason.is_some() {
+ stop_reason = output.stop_reason;
+ }
}
}
}
- if outputs.is_empty() {
- outputs.push(ResponseOutput {
+ let outputs = vec![if has_output {
+ ResponseOutput {
+ role,
+ content,
+ stop_reason,
+ }
+ } else {
+ ResponseOutput {
role: Role::Assistant,
content: vec![ContentBlock::Text {
text: String::new(),
}],
stop_reason: Some(StopReason::EndTurn),
- });
- }
+ }
+ }];
let response = AggLlmResponse {
id: body
.get("id")
diff --git a/crates/switchyard-translation/tests/response_translation.rs b/crates/switchyard-translation/tests/response_translation.rs
index e963af555..c837fa08b 100644
--- a/crates/switchyard-translation/tests/response_translation.rs
+++ b/crates/switchyard-translation/tests/response_translation.rs
@@ -122,6 +122,60 @@ fn responses_reasoning_usage_translates_to_openai_chat_usage_details() -> TestRe
Ok(())
}
+// Verifies Responses reasoning and its following message remain one semantic assistant output.
+#[test]
+fn responses_reasoning_and_message_preserve_the_final_answer() -> TestResult {
+ let engine = TranslationEngine::default();
+ let body = json!({
+ "id": "resp_test",
+ "object": "response",
+ "model": "gpt-reasoning",
+ "status": "completed",
+ "output": [
+ {
+ "type": "reasoning",
+ "summary": [{"type": "summary_text", "text": "private reasoning"}]
+ },
+ {
+ "type": "message",
+ "role": "assistant",
+ "content": [{"type": "output_text", "text": "Visible answer"}]
+ }
+ ]
+ });
+
+ let anthropic = engine
+ .translate_response(
+ WireFormat::OpenAiResponses,
+ WireFormat::AnthropicMessages,
+ &body,
+ &TranslationPolicy::default(),
+ )?
+ .body;
+ assert_eq!(
+ anthropic["content"],
+ json!([
+ {"type": "thinking", "thinking": "private reasoning", "signature": ""},
+ {"type": "text", "text": "Visible answer"}
+ ])
+ );
+
+ let chat = engine
+ .translate_response(
+ WireFormat::OpenAiResponses,
+ WireFormat::OpenAiChat,
+ &body,
+ &TranslationPolicy::default(),
+ )?
+ .body;
+ assert_eq!(chat["choices"][0]["message"]["content"], "Visible answer");
+ assert_eq!(
+ chat["choices"][0]["message"]["reasoning_content"],
+ "private reasoning"
+ );
+ Ok(())
+}
+
// Verifies OpenAI cache usage survives the Chat-to-Responses translation used by Codex.
#[test]
fn openai_chat_cache_usage_translates_to_responses_usage_details() -> TestResult {
diff --git a/crates/switchyard-translation/tests/stream_translation.rs b/crates/switchyard-translation/tests/stream_translation.rs
index d97eee149..b4b574a31 100644
--- a/crates/switchyard-translation/tests/stream_translation.rs
+++ b/crates/switchyard-translation/tests/stream_translation.rs
@@ -837,6 +837,64 @@ fn anthropic_message_stop_does_not_overwrite_max_tokens_stop_reason() -> TestRes
Ok(())
}
+// Equivalent buffered and streamed Responses results must normalize to the same output.
+#[test]
+fn responses_buffered_and_streamed_outputs_match() -> TestResult {
+ let engine = TranslationEngine::default();
+ let buffered = engine
+ .decode_response(
+ WireFormat::OpenAiResponses,
+ &json!({
+ "id": "resp_1",
+ "object": "response",
+ "model": "gpt-reasoning",
+ "status": "completed",
+ "output": [
+ {
+ "type": "reasoning",
+ "summary": [{"type": "summary_text", "text": "private reasoning"}]
+ },
+ {
+ "type": "message",
+ "role": "assistant",
+ "content": [{"type": "output_text", "text": "Visible answer"}]
+ }
+ ]
+ }),
+ &Default::default(),
+ )?
+ .response;
+
+ let events = [
+ json!({
+ "type": "response.created",
+ "response": {"id": "resp_1", "model": "gpt-reasoning"}
+ }),
+ json!({
+ "type": "response.reasoning_summary_text.delta",
+ "output_index": 0,
+ "delta": "private reasoning"
+ }),
+ json!({
+ "type": "response.output_text.delta",
+ "output_index": 1,
+ "delta": "Visible answer"
+ }),
+ json!({"type": "response.completed", "response": {}}),
+ ];
+ let mut state =
+ StreamTranslationState::new(WireFormat::OpenAiResponses, WireFormat::OpenAiResponses);
+ let mut accumulator = ResponseAccumulator::new();
+ for event in &events {
+ for chunk in decode_stream_event(&mut state, WireFormat::OpenAiResponses, event) {
+ accumulator.push(chunk);
+ }
+ }
+
+ assert_eq!(buffered.outputs, accumulator.finish().outputs);
+ Ok(())
+}
+
// An OpenAI-shaped error frame carries no `choices`, so it must decode to a stream error
// instead of a bare message start that silently drops the upstream message.
#[test]