feat: reasoing api

crates/backends/xlai-backend-openai/src/lib.rs

@@ -362,6 +362,24 @@ impl ChatModel for OpenAiChatModel {
                                 });
                             }
                         }
+                        Some("response.reasoning_summary_text.delta") => {
+                            let output_index = event_value
+                                .get("output_index")
+                                .and_then(Value::as_u64)
+                                .unwrap_or(0) as usize;
+                            let summary_index = event_value
+                                .get("summary_index")
+                                .and_then(Value::as_u64)
+                                .unwrap_or(0) as usize;
+                            if let Some(delta) = event_value.get("delta").and_then(Value::as_str) {
+                                let chunk = state.apply_reasoning_summary_delta(
+                                    output_index,
+                                    summary_index,
+                                    delta.to_owned(),
+                                );
+                                yield ChatChunk::ReasoningSummaryDelta(chunk);
+                            }
+                        }
                         Some("response.output_item.added") => {
                             if let Some(item) = event_value.get("item").and_then(Value::as_object)
                             {

crates/backends/xlai-backend-openai/src/request.rs

@@ -3,7 +3,7 @@ use serde::Serialize;
 use serde_json::Value;
 use xlai_core::{
     ChatMessage, ChatRequest, ContentPart, ErrorKind, ImageDetail, MediaSource, MessageRole,
-    StructuredOutputFormat, ToolCall, ToolDefinition, XlaiError,
+    ReasoningEffort, ReasoningSummary, StructuredOutputFormat, ToolCall, ToolDefinition, XlaiError,
 };
 
 use crate::OpenAiConfig;
@@ -83,11 +83,7 @@ impl OpenAiChatRequest {
                 .collect(),
             temperature: request.temperature,
             max_output_tokens: request.max_output_tokens,
-            reasoning: request
-                .reasoning_effort
-                .map(|effort| OpenAiReasoningConfig {
-                    effort: reasoning_effort_openai(effort),
-                }),
+            reasoning: openai_reasoning_config(request.reasoning_effort, request.reasoning_summary),
             tool_choice: tools.as_ref().map(|_| "auto"),
             tools,
             text,
@@ -241,7 +237,10 @@ const fn image_detail_openai(detail: ImageDetail) -> &'static str {
 
 #[derive(Serialize)]
 struct OpenAiReasoningConfig {
-    effort: &'static str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    effort: Option<&'static str>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    summary: Option<&'static str>,
 }
 
 #[derive(Serialize)]
@@ -293,10 +292,38 @@ fn tool_json_schema(tool: &ToolDefinition) -> Value {
     tool.resolved_input_schema().json_schema()
 }
 
-const fn reasoning_effort_openai(effort: xlai_core::ReasoningEffort) -> &'static str {
+const fn openai_reasoning_config(
+    effort: Option<ReasoningEffort>,
+    summary: Option<ReasoningSummary>,
+) -> Option<OpenAiReasoningConfig> {
+    if effort.is_none() && summary.is_none() {
+        return None;
+    }
+
+    Some(OpenAiReasoningConfig {
+        effort: match effort {
+            Some(effort) => Some(reasoning_effort_openai(effort)),
+            None => None,
+        },
+        summary: match summary {
+            Some(summary) => Some(reasoning_summary_openai(summary)),
+            None => None,
+        },
+    })
+}
+
+const fn reasoning_effort_openai(effort: ReasoningEffort) -> &'static str {
     match effort {
-        xlai_core::ReasoningEffort::Low => "low",
-        xlai_core::ReasoningEffort::Medium => "medium",
-        xlai_core::ReasoningEffort::High => "high",
+        ReasoningEffort::Low => "low",
+        ReasoningEffort::Medium => "medium",
+        ReasoningEffort::High => "high",
+    }
+}
+
+const fn reasoning_summary_openai(summary: ReasoningSummary) -> &'static str {
+    match summary {
+        ReasoningSummary::Auto => "auto",
+        ReasoningSummary::Concise => "concise",
+        ReasoningSummary::Detailed => "detailed",
     }
 }

crates/backends/xlai-backend-openai/src/response.rs

@@ -4,7 +4,8 @@ use serde::Deserialize;
 use serde_json::Value;
 use xlai_core::{
     ChatContent, ChatMessage, ChatResponse, ContentPart, ErrorKind, FinishReason, MediaSource,
-    MessageRole, TokenUsage, TokenUsageSource, ToolCall, XlaiError,
+    MessageRole, TokenUsage, TokenUsageSource, ToolCall, XLAI_REASONING_SUMMARY_METADATA_KEY,
+    XlaiError,
 };
 
 pub(crate) const OPENAI_RESPONSE_OUTPUT_METADATA_KEY: &str = "openai_response_output";
@@ -24,16 +25,20 @@ pub(crate) struct OpenAiChatResponse {
 impl OpenAiChatResponse {
     pub(crate) fn into_core_response(self) -> Result<ChatResponse, XlaiError> {
         let (content, tool_calls) = openai_response_output_to_chat(&self.output)?;
-        let message = attach_response_output_items(
-            ChatMessage {
-                role: MessageRole::Assistant,
-                content,
-                tool_name: None,
-                tool_call_id: None,
-                metadata: BTreeMap::new(),
-            }
-            .with_assistant_tool_calls(&tool_calls),
-            &self.output,
+        let reasoning_summary = reasoning_summary_from_response_output(&self.output);
+        let message = attach_reasoning_summary(
+            attach_response_output_items(
+                ChatMessage {
+                    role: MessageRole::Assistant,
+                    content,
+                    tool_name: None,
+                    tool_call_id: None,
+                    metadata: BTreeMap::new(),
+                }
+                .with_assistant_tool_calls(&tool_calls),
+                &self.output,
+            ),
+            &reasoning_summary,
         );
 
         let has_tool_calls = !tool_calls.is_empty();
@@ -88,6 +93,19 @@ pub(crate) fn attach_response_output_items(
     message
 }
 
+pub(crate) fn attach_reasoning_summary(
+    mut message: ChatMessage,
+    summary: &[String],
+) -> ChatMessage {
+    if !summary.is_empty() {
+        message.metadata.insert(
+            XLAI_REASONING_SUMMARY_METADATA_KEY.to_owned(),
+            Value::Array(summary.iter().cloned().map(Value::String).collect()),
+        );
+    }
+    message
+}
+
 pub(crate) fn response_output_items_from_message(message: &ChatMessage) -> Option<Vec<Value>> {
     message
         .metadata
@@ -138,6 +156,32 @@ pub(crate) fn openai_response_output_to_chat(
     Ok((content, tool_calls))
 }
 
+pub(crate) fn reasoning_summary_from_response_output(output: &[Value]) -> Vec<String> {
+    let mut summaries = Vec::new();
+    for item in output {
+        let Some(obj) = item.as_object() else {
+            continue;
+        };
+        if obj.get("type").and_then(Value::as_str) != Some("reasoning") {
+            continue;
+        }
+        let Some(summary_items) = obj.get("summary").and_then(Value::as_array) else {
+            continue;
+        };
+        summaries.extend(
+            summary_items
+                .iter()
+                .filter_map(parse_reasoning_summary_part),
+        );
+    }
+    summaries
+}
+
+fn parse_reasoning_summary_part(value: &Value) -> Option<String> {
+    let obj = value.as_object()?;
+    obj.get("text").and_then(Value::as_str).map(str::to_owned)
+}
+
 fn parse_openai_response_content_part(value: &Value) -> Option<ContentPart> {
     let obj = value.as_object()?;
     match obj.get("type")?.as_str()? {
@@ -247,6 +291,7 @@ pub(crate) fn finish_reason_from_api(
 #[allow(clippy::expect_used, clippy::panic)]
 mod tests {
     use serde_json::json;
+    use xlai_core::XLAI_REASONING_SUMMARY_METADATA_KEY;
 
     use super::OpenAiChatResponse;
 
@@ -279,4 +324,45 @@ mod tests {
         assert_eq!(usage.cached_input_tokens, Some(12));
         assert_eq!(usage.uncached_input_tokens, Some(8));
     }
+
+    #[test]
+    fn maps_reasoning_summary_to_message_metadata() {
+        let parsed = serde_json::from_value::<OpenAiChatResponse>(json!({
+            "output": [
+                {
+                    "type": "reasoning",
+                    "summary": [
+                        { "type": "summary_text", "text": "Checked constraints." }
+                    ]
+                },
+                {
+                    "type": "message",
+                    "content": [
+                        { "type": "output_text", "text": "Final answer." }
+                    ]
+                }
+            ],
+            "status": "completed"
+        }));
+        let Ok(response) = parsed else {
+            panic!("deserialize response");
+        };
+
+        let mapped = response.into_core_response();
+        let Ok(response) = mapped else {
+            panic!("map response");
+        };
+
+        assert_eq!(
+            response
+                .message
+                .metadata
+                .get(XLAI_REASONING_SUMMARY_METADATA_KEY),
+            Some(&json!(["Checked constraints."]))
+        );
+        assert_eq!(
+            response.message.content.text_parts_concatenated(),
+            "Final answer."
+        );
+    }
 }

crates/backends/xlai-backend-openai/src/stream.rs

@@ -2,13 +2,13 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use serde_json::Value;
 use xlai_core::{
-    ChatContent, ChatMessage, ChatResponse, ErrorKind, FinishReason, MessageRole, ToolCall,
-    ToolCallChunk, XlaiError,
+    ChatContent, ChatMessage, ChatResponse, ErrorKind, FinishReason, MessageRole,
+    ReasoningSummaryDelta, ToolCall, ToolCallChunk, XlaiError,
 };
 
 use crate::response::{
-    OpenAiChatResponse, attach_response_output_items, finish_reason_from_api,
-    openai_response_output_to_chat,
+    OpenAiChatResponse, attach_reasoning_summary, attach_response_output_items,
+    finish_reason_from_api, openai_response_output_to_chat, reasoning_summary_from_response_output,
 };
 
 pub(crate) struct StreamState {
@@ -17,6 +17,7 @@ pub(crate) struct StreamState {
     pub(crate) finish_reason: FinishReason,
     output_items: Vec<Value>,
     started_message_indices: BTreeSet<usize>,
+    reasoning_summary: BTreeMap<(usize, usize), String>,
 }
 
 impl Default for StreamState {
@@ -27,6 +28,7 @@ impl Default for StreamState {
             finish_reason: FinishReason::Completed,
             output_items: Vec::new(),
             started_message_indices: BTreeSet::new(),
+            reasoning_summary: BTreeMap::new(),
         }
     }
 }
@@ -80,6 +82,23 @@ impl StreamState {
         self.output_items.push(item);
     }
 
+    pub(crate) fn apply_reasoning_summary_delta(
+        &mut self,
+        output_index: usize,
+        summary_index: usize,
+        delta: String,
+    ) -> ReasoningSummaryDelta {
+        self.reasoning_summary
+            .entry((output_index, summary_index))
+            .or_default()
+            .push_str(&delta);
+        ReasoningSummaryDelta {
+            output_index,
+            summary_index,
+            delta,
+        }
+    }
+
     pub(crate) fn mark_message_started(&mut self, message_index: usize) -> bool {
         self.started_message_indices.insert(message_index)
     }
@@ -89,6 +108,14 @@ impl StreamState {
     }
 
     pub(crate) fn into_chat_response(self) -> Result<ChatResponse, XlaiError> {
+        let reasoning_summary = if self.output_items.is_empty() {
+            self.reasoning_summary
+                .into_values()
+                .filter(|summary| !summary.is_empty())
+                .collect::<Vec<_>>()
+        } else {
+            reasoning_summary_from_response_output(&self.output_items)
+        };
         let (content, tool_calls) = if self.output_items.is_empty() {
             let tool_calls = self
                 .tool_calls
@@ -102,16 +129,19 @@ impl StreamState {
         };
 
         Ok(ChatResponse {
-            message: attach_response_output_items(
-                ChatMessage {
-                    role: MessageRole::Assistant,
-                    content,
-                    tool_name: None,
-                    tool_call_id: None,
-                    metadata: BTreeMap::new(),
-                }
-                .with_assistant_tool_calls(&tool_calls),
-                &self.output_items,
+            message: attach_reasoning_summary(
+                attach_response_output_items(
+                    ChatMessage {
+                        role: MessageRole::Assistant,
+                        content,
+                        tool_name: None,
+                        tool_call_id: None,
+                        metadata: BTreeMap::new(),
+                    }
+                    .with_assistant_tool_calls(&tool_calls),
+                    &self.output_items,
+                ),
+                &reasoning_summary,
             ),
             tool_calls,
             usage: None,
@@ -228,6 +258,8 @@ pub(crate) fn maybe_completed_response(event: &Value) -> Result<Option<ChatRespo
 #[cfg(test)]
 mod sse_parser_tests {
     use super::{SseParser, StreamState};
+    use serde_json::json;
+    use xlai_core::XLAI_REASONING_SUMMARY_METADATA_KEY;
 
     #[test]
     fn splits_events_on_lf_only_delimiter() {
@@ -265,6 +297,28 @@ mod sse_parser_tests {
         assert!(state.mark_message_started(1));
     }
 
+    #[test]
+    fn stream_state_preserves_reasoning_summary_deltas() {
+        let mut state = StreamState::default();
+        let first = state.apply_reasoning_summary_delta(0, 0, "Checked ".to_owned());
+        let second = state.apply_reasoning_summary_delta(0, 0, "constraints.".to_owned());
+
+        assert_eq!(first.delta, "Checked ");
+        assert_eq!(second.summary_index, 0);
+        let response = state.into_chat_response();
+        assert!(response.is_ok(), "response should build: {response:?}");
+        let Ok(response) = response else {
+            return;
+        };
+        assert_eq!(
+            response
+                .message
+                .metadata
+                .get(XLAI_REASONING_SUMMARY_METADATA_KEY),
+            Some(&json!(["Checked constraints."]))
+        );
+    }
+
     #[test]
     fn preserves_utf8_across_chunk_boundaries() {
         let mut p = SseParser::default();