merge reasoning and content messages for openai chat completions

crates/lingua/src/processing/transform.rs

@@ -22,9 +22,10 @@ use crate::providers::openai::model_needs_transforms;
 use crate::serde_json;
 use crate::serde_json::Value;
 use crate::universal::{
-    AssistantContent, AssistantContentPart, Message, UniversalReasoningDelta, UniversalRequest,
-    UniversalResponse, UniversalStreamChoice, UniversalStreamChunk, UniversalStreamDelta,
-    UniversalToolCallDelta, UniversalToolFunctionDelta, UserContent, UserContentPart,
+    AssistantContent, AssistantContentPart, Message, TextContentPart, UniversalReasoningDelta,
+    UniversalRequest, UniversalResponse, UniversalStreamChoice, UniversalStreamChunk,
+    UniversalStreamDelta, UniversalToolCallDelta, UniversalToolFunctionDelta, UserContent,
+    UserContentPart,
 };
 use serde::de::DeserializeOwned;
 use thiserror::Error;
@@ -465,6 +466,83 @@ pub fn request_to_universal(input: Bytes) -> Result<UniversalRequest, TransformE
 // Response transformation
 // ============================================================================
 
+fn is_reasoning_only_response_message(msg: &Message) -> bool {
+    match msg {
+        Message::Assistant {
+            content: AssistantContent::Array(parts),
+            ..
+        } => {
+            !parts.is_empty()
+                && parts
+                    .iter()
+                    .all(|part| matches!(part, AssistantContentPart::Reasoning { .. }))
+        }
+        _ => false,
+    }
+}
+
+fn merge_responses_output_parts_for_chat_completions(messages: Vec<Message>) -> Vec<Message> {
+    let mut merged = Vec::with_capacity(messages.len());
+
+    for message in messages {
+        let should_merge = matches!(merged.last(), Some(prev) if is_reasoning_only_response_message(prev))
+            && matches!(message, Message::Assistant { .. });
+
+        if !should_merge {
+            merged.push(message);
+            continue;
+        }
+
+        let Some(previous) = merged.pop() else {
+            merged.push(message);
+            continue;
+        };
+
+        let Message::Assistant {
+            content: AssistantContent::Array(reasoning_parts),
+            id: reasoning_id,
+        } = previous
+        else {
+            merged.push(previous);
+            merged.push(message);
+            continue;
+        };
+
+        let Message::Assistant {
+            content: next_content,
+            id: next_id,
+        } = message
+        else {
+            merged.push(Message::Assistant {
+                content: AssistantContent::Array(reasoning_parts),
+                id: reasoning_id,
+            });
+            merged.push(message);
+            continue;
+        };
+
+        let mut combined_parts = reasoning_parts;
+        match next_content {
+            AssistantContent::Array(parts) => combined_parts.extend(parts),
+            AssistantContent::String(text) => {
+                combined_parts.push(AssistantContentPart::Text(TextContentPart {
+                    text,
+                    encrypted_content: None,
+                    cache_control: None,
+                    provider_options: None,
+                }));
+            }
+        }
+
+        merged.push(Message::Assistant {
+            content: AssistantContent::Array(combined_parts),
+            id: next_id.or(reasoning_id),
+        });
+    }
+
+    merged
+}
+
 /// Transform a response payload from one format to another.
 ///
 /// # Arguments
@@ -495,7 +573,16 @@ pub fn transform_response(
     let target_adapter = adapter_for_format(target_format)
         .ok_or(TransformError::UnsupportedTargetFormat(target_format))?;
 
-    let universal_resp = source_adapter.response_to_universal(response)?;
+    let mut universal_resp = source_adapter.response_to_universal(response)?;
+    if source_format == ProviderFormat::Responses
+        && matches!(
+            target_format,
+            ProviderFormat::ChatCompletions | ProviderFormat::Google
+        )
+    {
+        universal_resp.messages =
+            merge_responses_output_parts_for_chat_completions(universal_resp.messages);
+    }
     let transformed = target_adapter.response_from_universal(&universal_resp)?;
 
     let bytes = crate::serde_json::to_vec(&transformed)

crates/lingua/src/providers/openai/responses_adapter.rs

@@ -1558,6 +1558,154 @@ mod tests {
         );
     }
 
+    #[test]
+    fn responses_reasoning_then_message_transforms_to_chat_content() {
+        let payload = json!({
+            "id": "resp_123",
+            "object": "response",
+            "model": "gpt-5.5",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "reasoning",
+                    "id": "rs_123",
+                    "summary": [],
+                    "encrypted_content": "encrypted-reasoning"
+                },
+                {
+                    "type": "message",
+                    "id": "msg_123",
+                    "status": "completed",
+                    "role": "assistant",
+                    "content": [{
+                        "type": "output_text",
+                        "text": "visible answer",
+                        "annotations": []
+                    }]
+                }
+            ],
+            "usage": {
+                "input_tokens": 10,
+                "output_tokens": 12,
+                "output_tokens_details": {
+                    "reasoning_tokens": 4
+                },
+                "total_tokens": 22
+            }
+        });
+
+        let transformed = transform_response(
+            Bytes::from(payload.to_string()),
+            ProviderFormat::ChatCompletions,
+        )
+        .expect("Responses response should transform to Chat Completions")
+        .into_bytes();
+
+        #[derive(serde::Deserialize)]
+        struct ChatResponse {
+            choices: Vec<ChatChoice>,
+        }
+
+        #[derive(serde::Deserialize)]
+        struct ChatChoice {
+            message: ChatMessage,
+        }
+
+        #[derive(serde::Deserialize)]
+        struct ChatMessage {
+            content: Option<String>,
+            reasoning: Option<String>,
+            reasoning_signature: Option<String>,
+        }
+
+        let chat: ChatResponse = serde_json::from_slice(&transformed).unwrap();
+
+        assert_eq!(chat.choices.len(), 1);
+        assert_eq!(
+            chat.choices[0].message.content.as_deref(),
+            Some("visible answer")
+        );
+        assert_eq!(chat.choices[0].message.reasoning.as_deref(), Some(""));
+        assert_eq!(
+            chat.choices[0].message.reasoning_signature.as_deref(),
+            Some("encrypted-reasoning")
+        );
+    }
+
+    #[test]
+    fn responses_reasoning_then_message_preserves_output_item_ids_in_universal() {
+        let adapter = ResponsesAdapter;
+        let payload = json!({
+            "id": "resp_123",
+            "object": "response",
+            "model": "gpt-5.5",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "reasoning",
+                    "id": "rs_123",
+                    "summary": [],
+                    "encrypted_content": "encrypted-reasoning"
+                },
+                {
+                    "type": "message",
+                    "id": "msg_123",
+                    "status": "completed",
+                    "role": "assistant",
+                    "content": [{
+                        "type": "output_text",
+                        "text": "visible answer",
+                        "annotations": []
+                    }]
+                }
+            ]
+        });
+
+        let universal = adapter
+            .response_to_universal(payload)
+            .expect("Responses output should convert to universal");
+
+        assert_eq!(universal.messages.len(), 2);
+        assert!(matches!(
+            &universal.messages[0],
+            Message::Assistant {
+                id: Some(id),
+                content: AssistantContent::Array(parts),
+            } if id == "rs_123" && matches!(parts.as_slice(), [AssistantContentPart::Reasoning { .. }])
+        ));
+        assert!(matches!(
+            &universal.messages[1],
+            Message::Assistant {
+                id: Some(id),
+                content: AssistantContent::Array(parts),
+            } if id == "msg_123" && matches!(parts.as_slice(), [AssistantContentPart::Text(_)])
+        ));
+
+        #[derive(serde::Deserialize)]
+        struct ResponsesOutput {
+            output: Vec<ResponsesOutputItem>,
+        }
+
+        #[derive(serde::Deserialize)]
+        struct ResponsesOutputItem {
+            id: String,
+        }
+
+        let serialized = adapter
+            .response_from_universal(&universal)
+            .expect("Universal response should convert back to Responses");
+        let responses: ResponsesOutput = serde_json::from_value(serialized).unwrap();
+
+        assert_eq!(
+            responses
+                .output
+                .iter()
+                .map(|item| item.id.clone())
+                .collect::<Vec<_>>(),
+            vec!["rs_123".to_string(), "msg_123".to_string()]
+        );
+    }
+
     #[test]
     fn test_responses_preserves_deferred_namespace_tool_search_tools() {
         let adapter = ResponsesAdapter;