Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

codex: surface reasoning summaries

Raine Virta5725b49f44c4
diff --git a/src/config.rs b/src/config.rs
index 376b073..bd0c605 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -52,6 +52,8 @@ struct CodexConfig {
pub previous_response_id: Option<bool>,
#[serde(rename = "serviceTier")]
pub service_tier: Option<String>,
+ #[serde(rename = "reasoningSummary")]
+ pub reasoning_summary: Option<String>,
#[serde(rename = "effort")]
pub effort: Option<String>,
#[serde(rename = "model")]
@@ -204,6 +206,12 @@ pub fn config_override_summary_lines(cfg: &LoadedConfig) -> Vec<String> {
if env.contains_key("CCP_KIMI_USER_AGENT") {
out.push("kimi.userAgent (env)".to_string());
}
+ if env
+ .get("CCP_CODEX_REASONING_SUMMARY")
+ .is_some_and(|raw| !raw.is_empty())
+ {
+ out.push("CCP_CODEX_REASONING_SUMMARY (env)".to_string());
+ }
if let Some(file_cfg) = file {
if let Some(p) = file_cfg.port {
out.push(format!("port: {p}"));
@@ -219,6 +227,12 @@ pub fn config_override_summary_lines(cfg: &LoadedConfig) -> Vec<String> {
out.push(format!("log.stderr: {v}"));
}
}
+ if let Some(codex) = file_cfg.codex
+ && let Some(summary) = codex.reasoning_summary
+ && !summary.is_empty()
+ {
+ out.push("codex.reasoningSummary (config)".to_string());
+ }
}
out
}
@@ -373,6 +387,24 @@ pub fn codex_effort() -> Option<String> {
None
}
+pub fn codex_reasoning_summary() -> Option<String> {
+ let env: HashMap<_, _> = std::env::vars().collect();
+ if let Some(raw) = env
+ .get("CCP_CODEX_REASONING_SUMMARY")
+ .filter(|raw| !raw.is_empty())
+ {
+ return Some(raw.clone());
+ }
+ let config_dir = paths::config_dir();
+ if let Some(file) = read_file_config(&config_dir)
+ && let Some(codex) = file.codex
+ && let Some(summary) = codex.reasoning_summary.filter(|raw| !raw.is_empty())
+ {
+ return Some(summary);
+ }
+ None
+}
+
pub fn codex_model() -> Option<String> {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_MODEL") {
@@ -497,6 +529,7 @@ mod tests {
std::env::remove_var("CCP_CONFIG_DIR");
std::env::remove_var("CCP_LOG_VERBOSE");
std::env::remove_var("CCP_LOG_STDERR");
+ std::env::remove_var("CCP_CODEX_REASONING_SUMMARY");
}
}
@@ -624,4 +657,40 @@ mod tests {
assert!(loaded.log_verbose);
assert!(loaded.log_stderr);
}
+
+ #[test]
+ fn codex_reasoning_summary_reads_config() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ clear_env();
+ let config = tempfile::TempDir::new().unwrap();
+ std::fs::write(
+ config.path().join("config.json"),
+ r#"{"codex":{"reasoningSummary":"off"}}"#,
+ )
+ .unwrap();
+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
+
+ assert_eq!(codex_reasoning_summary().as_deref(), Some("off"));
+ }
+
+ #[test]
+ fn codex_reasoning_summary_env_overrides_config_and_empty_falls_through() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ clear_env();
+ let config = tempfile::TempDir::new().unwrap();
+ std::fs::write(
+ config.path().join("config.json"),
+ r#"{"codex":{"reasoningSummary":"off"}}"#,
+ )
+ .unwrap();
+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
+ {
+ let _summary_env = EnvGuard::set("CCP_CODEX_REASONING_SUMMARY", "auto");
+ assert_eq!(codex_reasoning_summary().as_deref(), Some("auto"));
+ }
+ {
+ let _summary_env = EnvGuard::set("CCP_CODEX_REASONING_SUMMARY", "");
+ assert_eq!(codex_reasoning_summary().as_deref(), Some("off"));
+ }
+ }
}
diff --git a/src/providers/codex/translate/accumulate.rs b/src/providers/codex/translate/accumulate.rs
index afb25c7..3df5c5a 100644
--- a/src/providers/codex/translate/accumulate.rs
+++ b/src/providers/codex/translate/accumulate.rs
@@ -41,6 +41,9 @@ pub fn accumulate_response_with_traffic(
let mut deferred_text_parts: Vec<String> = Vec::new();
enum BlockKind {
+ Thinking {
+ text: String,
+ },
Text {
text: String,
},
@@ -61,6 +64,21 @@ pub fn accumulate_response_with_traffic(
ReducerEvent::WebSearch { .. } => {
web_search_events.push(event.clone());
}
+ ReducerEvent::ThinkingStart { index } => {
+ blocks.push(AccumulatedBlock {
+ index: *index,
+ kind: BlockKind::Thinking {
+ text: String::new(),
+ },
+ });
+ }
+ ReducerEvent::ThinkingDelta { index, text } => {
+ if let Some(block) = blocks.iter_mut().rev().find(|b| b.index == *index)
+ && let BlockKind::Thinking { text: t } = &mut block.kind
+ {
+ t.push_str(text);
+ }
+ }
ReducerEvent::TextStart { index } => {
blocks.push(AccumulatedBlock {
index: *index,
@@ -113,21 +131,22 @@ pub fn accumulate_response_with_traffic(
let text_from_deferred: String = deferred_text_parts.join("");
- // Build content array
- let mut content: Vec<Value> = Vec::new();
+ let mut indexed_content: Vec<(usize, Value)> = Vec::new();
- // Add web search compat blocks
if !web_search_events.is_empty() {
let compat_blocks = build_web_search_compat_blocks(&web_search_events, &text_from_deferred);
for block in &compat_blocks {
match &block.content {
WebSearchCompatContent::ServerToolUse { id, name, input } => {
- content.push(serde_json::json!({
- "type": "server_tool_use",
- "id": id,
- "name": name,
- "input": input,
- }));
+ indexed_content.push((
+ block.index,
+ serde_json::json!({
+ "type": "server_tool_use",
+ "id": id,
+ "name": name,
+ "input": input,
+ }),
+ ));
}
WebSearchCompatContent::WebSearchToolResult {
tool_use_id,
@@ -143,40 +162,66 @@ pub fn accumulate_response_with_traffic(
})
})
.collect();
- content.push(serde_json::json!({
- "type": "web_search_tool_result",
- "tool_use_id": tool_use_id,
- "content": result_content,
- }));
+ indexed_content.push((
+ block.index,
+ serde_json::json!({
+ "type": "web_search_tool_result",
+ "tool_use_id": tool_use_id,
+ "content": result_content,
+ }),
+ ));
}
}
}
}
- // Add accumulated blocks
for block in &blocks {
match &block.kind {
+ BlockKind::Thinking { text } => {
+ if !text.is_empty() {
+ indexed_content.push((
+ block.index,
+ serde_json::json!({
+ "type": "thinking",
+ "thinking": text,
+ "signature": "",
+ }),
+ ));
+ }
+ }
BlockKind::Text { text } => {
if !text.is_empty() {
- content.push(serde_json::json!({
- "type": "text",
- "text": text,
- }));
+ indexed_content.push((
+ block.index,
+ serde_json::json!({
+ "type": "text",
+ "text": text,
+ }),
+ ));
}
}
BlockKind::Tool { id, name, args } => {
let parsed = serde_json::from_str::<Value>(args)
.unwrap_or_else(|_| Value::String(args.clone()));
- content.push(serde_json::json!({
- "type": "tool_use",
- "id": id,
- "name": name,
- "input": parsed,
- }));
+ indexed_content.push((
+ block.index,
+ serde_json::json!({
+ "type": "tool_use",
+ "id": id,
+ "name": name,
+ "input": parsed,
+ }),
+ ));
}
}
}
+ indexed_content.sort_by_key(|(index, _)| *index);
+ let content: Vec<Value> = indexed_content
+ .into_iter()
+ .map(|(_, content)| content)
+ .collect();
+
let response = serde_json::json!({
"id": message_id,
"type": "message",
@@ -364,6 +409,126 @@ mod tests {
assert_eq!(content[2]["type"], "text");
}
+ #[test]
+ fn accumulate_reasoning_summary_as_thinking_before_text() {
+ let upstream = format!(
+ "{}{}{}{}{}{}{}",
+ sse_event(
+ "response.reasoning_summary_text.delta",
+ json!({
+ "output_index":0,"summary_index":0,"delta":"part one"
+ })
+ ),
+ sse_event(
+ "response.reasoning_summary_part.added",
+ json!({
+ "output_index":0,
+ "summary_index":1,
+ "part":{"type":"summary_text","text":""}
+ })
+ ),
+ sse_event(
+ "response.reasoning_summary_text.delta",
+ json!({
+ "output_index":0,"summary_index":1,"delta":"part two"
+ })
+ ),
+ sse_event(
+ "response.output_item.done",
+ json!({
+ "output_index":0,
+ "item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}
+ })
+ ),
+ sse_event(
+ "response.output_item.added",
+ json!({
+ "output_index":1,
+ "item":{"type":"message","id":"msg_up"}
+ })
+ ),
+ sse_event(
+ "response.output_text.delta",
+ json!({
+ "output_index":1,"delta":"answer"
+ })
+ ),
+ format!(
+ "{}{}",
+ sse_event(
+ "response.output_item.done",
+ json!({
+ "output_index":1,"item":{"type":"message"}
+ })
+ ),
+ sse_event(
+ "response.completed",
+ json!({
+ "response":{"id":"resp_1","usage":{}}
+ })
+ )
+ ),
+ );
+ let response = accumulate_response(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();
+ let content = response["content"].as_array().unwrap();
+ assert_eq!(content[0]["type"], "thinking");
+ assert_eq!(content[0]["thinking"], "part one\n\npart two");
+ assert_eq!(content[0]["signature"], "");
+ assert_eq!(content[1]["type"], "text");
+ assert_eq!(content[1]["text"], "answer");
+ }
+
+ #[test]
+ fn accumulate_empty_reasoning_summary_emits_no_thinking() {
+ let upstream = format!(
+ "{}{}{}{}{}{}",
+ sse_event(
+ "response.output_item.added",
+ json!({
+ "output_index":0,
+ "item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}
+ })
+ ),
+ sse_event(
+ "response.output_item.done",
+ json!({
+ "output_index":0,
+ "item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}
+ })
+ ),
+ sse_event(
+ "response.output_item.added",
+ json!({
+ "output_index":1,
+ "item":{"type":"message","id":"msg_up"}
+ })
+ ),
+ sse_event(
+ "response.output_text.delta",
+ json!({
+ "output_index":1,"delta":"answer"
+ })
+ ),
+ sse_event(
+ "response.output_item.done",
+ json!({
+ "output_index":1,"item":{"type":"message"}
+ })
+ ),
+ sse_event(
+ "response.completed",
+ json!({
+ "response":{"id":"resp_1","usage":{}}
+ })
+ ),
+ );
+ let response = accumulate_response(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();
+ let content = response["content"].as_array().unwrap();
+ assert_eq!(content.len(), 1);
+ assert_eq!(content[0]["type"], "text");
+ assert_eq!(content[0]["text"], "answer");
+ }
+
#[test]
fn accumulate_handles_upstream_error() {
let upstream = sse_event("error", json!({"error":{"message":"upstream failure"}}));
diff --git a/src/providers/codex/translate/reducer.rs b/src/providers/codex/translate/reducer.rs
index 3caa572..4f4b5c5 100644
--- a/src/providers/codex/translate/reducer.rs
+++ b/src/providers/codex/translate/reducer.rs
@@ -61,6 +61,16 @@ pub const TERM_DONE: &str = "response.done";
#[derive(Debug, Clone)]
pub enum ReducerEvent {
+ ThinkingStart {
+ index: usize,
+ },
+ ThinkingDelta {
+ index: usize,
+ text: String,
+ },
+ ThinkingStop {
+ index: usize,
+ },
TextStart {
index: usize,
},
@@ -159,6 +169,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
let mut item_id_to_output_index: std::collections::HashMap<String, usize> =
std::collections::HashMap::new();
let mut anthropic_index = 0usize;
+ let mut thinking_index: Option<usize> = None;
let mut saw_tool_use = false;
let mut final_usage: Option<CodexUsage> = None;
let mut response_id: Option<String> = None;
@@ -211,6 +222,12 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
}
}
+ fn close_thinking(out: &mut Vec<ReducerEvent>, thinking_index: &mut Option<usize>) {
+ if let Some(index) = thinking_index.take() {
+ out.push(ReducerEvent::ThinkingStop { index });
+ }
+ }
+
for evt in &sse_events {
let data = evt.data.trim();
if data.is_empty() {
@@ -305,6 +322,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
}
if item_type == "message" {
+ close_thinking(&mut out, &mut thinking_index);
let idx = anthropic_index;
anthropic_index += 1;
if let Some(id) = item.get("id").and_then(|v| v.as_str()) {
@@ -322,6 +340,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
}
if item_type == "function_call" {
+ close_thinking(&mut out, &mut thinking_index);
saw_tool_use = true;
let idx = anthropic_index;
anthropic_index += 1;
@@ -360,7 +379,36 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
continue;
}
+ if t == "response.reasoning_summary_part.added" {
+ if let Some(index) = thinking_index {
+ out.push(ReducerEvent::ThinkingDelta {
+ index,
+ text: "\n\n".to_string(),
+ });
+ }
+ continue;
+ }
+
+ if t == "response.reasoning_summary_text.delta" {
+ let delta = p.get("delta").and_then(|v| v.as_str()).unwrap_or("");
+ if delta.is_empty() {
+ continue;
+ }
+ if thinking_index.is_none() {
+ let index = anthropic_index;
+ anthropic_index += 1;
+ thinking_index = Some(index);
+ out.push(ReducerEvent::ThinkingStart { index });
+ }
+ out.push(ReducerEvent::ThinkingDelta {
+ index: thinking_index.unwrap(),
+ text: delta.to_string(),
+ });
+ continue;
+ }
+
if t == "response.output_text.delta" {
+ close_thinking(&mut out, &mut thinking_index);
let output_index = p
.get("output_index")
.and_then(|v| v.as_u64())
@@ -472,10 +520,17 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
p.get("output_index").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
let item = p.get("item");
- // Handle web search call done
+ if let Some(item_val) = item
+ && item_val.get("type").and_then(|v| v.as_str()) == Some("reasoning")
+ {
+ close_thinking(&mut out, &mut thinking_index);
+ continue;
+ }
+
if let Some(item_val) = item
&& item_val.get("type").and_then(|v| v.as_str()) == Some("web_search_call")
{
+ close_thinking(&mut out, &mut thinking_index);
let idx = anthropic_index;
anthropic_index += 1;
let result_index = anthropic_index;
@@ -500,9 +555,6 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
};
if let Some(item_val) = item {
- if item_val.get("type").and_then(|v| v.as_str()) == Some("reasoning") {
- continue;
- }
if let BlockState::Tool {
args_accum,
name,
@@ -597,6 +649,8 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
});
}
+ close_thinking(&mut out, &mut thinking_index);
+
let stop_reason: StopReason = if incomplete {
STOP_MAX_TOKENS
} else if saw_tool_use {
@@ -1181,4 +1235,201 @@ mod tests {
assert_eq!(mapped.output_tokens, 50);
assert_eq!(mapped.cache_read_input_tokens, 20);
}
+
+ #[test]
+ fn reduce_reasoning_summary_before_text() {
+ let upstream = format!(
+ "{}{}{}{}{}{}",
+ sse(
+ "response.reasoning_summary_text.delta",
+ json!({"output_index":0,"summary_index":0,"delta":"Plan"})
+ ),
+ sse(
+ "response.reasoning_summary_text.delta",
+ json!({"output_index":0,"summary_index":0,"delta":"ning"})
+ ),
+ sse(
+ "response.output_item.done",
+ json!({"output_index":0,"item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}})
+ ),
+ sse(
+ "response.output_item.added",
+ json!({"output_index":1,"item":{"type":"message","id":"msg_up"}})
+ ),
+ sse(
+ "response.output_text.delta",
+ json!({"output_index":1,"delta":"answer"})
+ ),
+ format!(
+ "{}{}",
+ sse(
+ "response.output_item.done",
+ json!({"output_index":1,"item":{"type":"message"}})
+ ),
+ sse(
+ "response.completed",
+ json!({"response":{"id":"resp_1","usage":{}}})
+ )
+ ),
+ );
+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();
+ assert!(matches!(
+ out.iter()
+ .find(|event| matches!(event, ReducerEvent::ThinkingStart { .. })),
+ Some(ReducerEvent::ThinkingStart { index: 0 })
+ ));
+ let thinking_text: String = out
+ .iter()
+ .filter_map(|event| match event {
+ ReducerEvent::ThinkingDelta { text, .. } => Some(text.as_str()),
+ _ => None,
+ })
+ .collect();
+ assert_eq!(thinking_text, "Planning");
+ let thinking_stop = out
+ .iter()
+ .position(|event| matches!(event, ReducerEvent::ThinkingStop { .. }))
+ .unwrap();
+ let text_start = out
+ .iter()
+ .position(|event| matches!(event, ReducerEvent::TextStart { .. }))
+ .unwrap();
+ assert!(thinking_stop < text_start);
+ assert!(matches!(
+ out.iter()
+ .find(|event| matches!(event, ReducerEvent::TextStart { .. })),
+ Some(ReducerEvent::TextStart { index: 1 })
+ ));
+ }
+
+ #[test]
+ fn reduce_empty_reasoning_summary_emits_no_thinking() {
+ let upstream = format!(
+ "{}{}{}{}",
+ sse(
+ "response.output_item.added",
+ json!({"output_index":0,"item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}})
+ ),
+ sse(
+ "response.output_item.done",
+ json!({"output_index":0,"item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}})
+ ),
+ sse(
+ "response.output_item.added",
+ json!({"output_index":1,"item":{"type":"message","id":"msg_up"}})
+ ),
+ format!(
+ "{}{}{}",
+ sse(
+ "response.output_text.delta",
+ json!({"output_index":1,"delta":"answer"})
+ ),
+ sse(
+ "response.output_item.done",
+ json!({"output_index":1,"item":{"type":"message"}})
+ ),
+ sse(
+ "response.completed",
+ json!({"response":{"id":"resp_1","usage":{}}})
+ )
+ ),
+ );
+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();
+ assert!(!out.iter().any(|event| matches!(
+ event,
+ ReducerEvent::ThinkingStart { .. }
+ | ReducerEvent::ThinkingDelta { .. }
+ | ReducerEvent::ThinkingStop { .. }
+ )));
+ }
+
+ #[test]
+ fn reduce_multiple_reasoning_summary_parts() {
+ let upstream = format!(
+ "{}{}{}{}{}",
+ sse(
+ "response.reasoning_summary_text.delta",
+ json!({"output_index":0,"summary_index":0,"delta":"part one"})
+ ),
+ sse(
+ "response.reasoning_summary_part.added",
+ json!({"output_index":0,"summary_index":1,"part":{"type":"summary_text","text":""}})
+ ),
+ sse(
+ "response.reasoning_summary_text.delta",
+ json!({"output_index":0,"summary_index":1,"delta":"part two"})
+ ),
+ sse(
+ "response.output_item.done",
+ json!({"output_index":0,"item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}})
+ ),
+ sse(
+ "response.completed",
+ json!({"response":{"id":"resp_1","usage":{}}})
+ ),
+ );
+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();
+ let deltas: Vec<&str> = out
+ .iter()
+ .filter_map(|event| match event {
+ ReducerEvent::ThinkingDelta { text, .. } => Some(text.as_str()),
+ _ => None,
+ })
+ .collect();
+ assert_eq!(deltas, vec!["part one", "\n\n", "part two"]);
+ assert_eq!(
+ out.iter()
+ .filter(|event| matches!(event, ReducerEvent::ThinkingStop { .. }))
+ .count(),
+ 1
+ );
+ }
+
+ #[test]
+ fn reduce_two_reasoning_items() {
+ let upstream = format!(
+ "{}{}{}{}{}",
+ sse(
+ "response.reasoning_summary_text.delta",
+ json!({"output_index":0,"summary_index":0,"delta":"first"})
+ ),
+ sse(
+ "response.output_item.done",
+ json!({"output_index":0,"item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}})
+ ),
+ sse(
+ "response.reasoning_summary_text.delta",
+ json!({"output_index":1,"summary_index":0,"delta":"second"})
+ ),
+ sse(
+ "response.output_item.done",
+ json!({"output_index":1,"item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}})
+ ),
+ sse(
+ "response.completed",
+ json!({"response":{"id":"resp_1","usage":{}}})
+ ),
+ );
+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();
+ assert_eq!(
+ out.iter()
+ .filter(|event| matches!(event, ReducerEvent::ThinkingStart { .. }))
+ .count(),
+ 2
+ );
+ assert_eq!(
+ out.iter()
+ .filter(|event| matches!(event, ReducerEvent::ThinkingStop { .. }))
+ .count(),
+ 2
+ );
+ let deltas: Vec<&str> = out
+ .iter()
+ .filter_map(|event| match event {
+ ReducerEvent::ThinkingDelta { text, .. } => Some(text.as_str()),
+ _ => None,
+ })
+ .collect();
+ assert_eq!(deltas, vec!["first", "second"]);
+ }
}
diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rs
index 7ddaf50..282683f 100644
--- a/src/providers/codex/translate/request.rs
+++ b/src/providers/codex/translate/request.rs
@@ -78,6 +78,8 @@ pub struct ResponsesRequest {
pub struct ResponsesReasoning {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub effort: Option<Effort>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub summary: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -215,6 +217,10 @@ fn resolve_effort(effort: Option<Effort>) -> Result<Option<Effort>, anyhow::Erro
Ok(effort)
}
+fn reasoning_summary_requested(summary: Option<&str>) -> bool {
+ !matches!(summary, Some("off" | "none"))
+}
+
const VALID_SERVICE_TIERS: &[&str] = &["fast", "priority", "flex"];
fn normalize_service_tier(tier: &str) -> Result<ServiceTier, anyhow::Error> {
@@ -314,8 +320,14 @@ pub fn translate_request(
let codex_effort = to_codex_effort(effort);
let resolved_effort = resolve_effort(codex_effort)?;
if let Some(ref eff) = resolved_effort {
+ let summary = if reasoning_summary_requested(config::codex_reasoning_summary().as_deref()) {
+ Some("auto".to_string())
+ } else {
+ None
+ };
out.reasoning = Some(ResponsesReasoning {
effort: Some(eff.clone()),
+ summary,
});
out.include = Some(vec!["reasoning.encrypted_content".to_string()]);
}
@@ -674,7 +686,9 @@ mod tests {
}))
.unwrap();
let out = translate_request(&req, opts()).unwrap();
- assert!(out.reasoning.is_some());
+ let reasoning = out.reasoning.unwrap();
+ assert!(matches!(reasoning.effort, Some(Effort::Medium)));
+ assert_eq!(reasoning.summary.as_deref(), Some("auto"));
assert_eq!(
out.include,
Some(vec!["reasoning.encrypted_content".to_string()])
@@ -693,6 +707,15 @@ mod tests {
assert!(matches!(out.reasoning.unwrap().effort, Some(Effort::Xhigh)));
}
+ #[test]
+ fn reasoning_summary_override_values() {
+ assert!(reasoning_summary_requested(None));
+ assert!(reasoning_summary_requested(Some("auto")));
+ assert!(reasoning_summary_requested(Some("detailed")));
+ assert!(!reasoning_summary_requested(Some("off")));
+ assert!(!reasoning_summary_requested(Some("none")));
+ }
+
#[test]
fn translate_user_text_and_image() {
let req: MessagesRequest = serde_json::from_value(json!({
diff --git a/src/providers/codex/translate/stream.rs b/src/providers/codex/translate/stream.rs
index aec8f05..e12a219 100644
--- a/src/providers/codex/translate/stream.rs
+++ b/src/providers/codex/translate/stream.rs
@@ -10,6 +10,7 @@ use super::web_search_compat::build_web_search_compat_blocks;
#[allow(dead_code)]
enum OpenBlock {
+ Thinking,
Text,
Tool { id: String, name: String },
}
@@ -71,6 +72,47 @@ fn emit_content_event(
event: &ReducerEvent,
) -> bool {
match event {
+ ReducerEvent::ThinkingStart { index } => {
+ ensure_message_start(out, traffic, message_started, message_id, model);
+ open_blocks.insert(*index, OpenBlock::Thinking);
+ emit(
+ out,
+ traffic,
+ "content_block_start",
+ &serde_json::json!({
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {"type": "thinking", "thinking": "", "signature": ""}
+ }),
+ );
+ true
+ }
+ ReducerEvent::ThinkingDelta { index, text } => {
+ emit(
+ out,
+ traffic,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {"type": "thinking_delta", "thinking": text}
+ }),
+ );
+ true
+ }
+ ReducerEvent::ThinkingStop { index } => {
+ open_blocks.remove(index);
+ emit(
+ out,
+ traffic,
+ "content_block_stop",
+ &serde_json::json!({
+ "type": "content_block_stop",
+ "index": index,
+ }),
+ );
+ true
+ }
ReducerEvent::TextStart { index } => {
ensure_message_start(out, traffic, message_started, message_id, model);
open_blocks.insert(*index, OpenBlock::Text);
@@ -177,7 +219,10 @@ fn emit_content_event(
fn is_content_event(event: &ReducerEvent) -> bool {
matches!(
event,
- ReducerEvent::TextStart { .. }
+ ReducerEvent::ThinkingStart { .. }
+ | ReducerEvent::ThinkingDelta { .. }
+ | ReducerEvent::ThinkingStop { .. }
+ | ReducerEvent::TextStart { .. }
| ReducerEvent::TextDelta { .. }
| ReducerEvent::TextStop { .. }
| ReducerEvent::ToolStart { .. }
@@ -528,4 +573,118 @@ mod tests {
"missing web_search_tool_result"
);
}
+
+ #[test]
+ fn stream_translates_reasoning_summary_to_thinking() {
+ let upstream = format!(
+ "{}{}{}{}{}{}",
+ sse_event(
+ "response.reasoning_summary_text.delta",
+ serde_json::json!({
+ "output_index":0,"summary_index":0,"delta":"Working it out"
+ })
+ ),
+ sse_event(
+ "response.output_item.done",
+ serde_json::json!({
+ "output_index":0,
+ "item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}
+ })
+ ),
+ sse_event(
+ "response.output_item.added",
+ serde_json::json!({
+ "output_index":1,
+ "item":{"type":"message","id":"msg_up"}
+ })
+ ),
+ sse_event(
+ "response.output_text.delta",
+ serde_json::json!({
+ "output_index":1,"delta":"answer"
+ })
+ ),
+ sse_event(
+ "response.output_item.done",
+ serde_json::json!({
+ "output_index":1,"item":{"type":"message"}
+ })
+ ),
+ sse_event(
+ "response.completed",
+ serde_json::json!({
+ "response":{"id":"resp_1","usage":{}}
+ })
+ ),
+ );
+ let out = String::from_utf8(
+ translate_stream_bytes(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap(),
+ )
+ .unwrap();
+ assert!(out.contains("\"type\":\"thinking\""));
+ assert!(out.contains("\"signature\":\"\""));
+ assert!(out.contains("\"type\":\"thinking_delta\""));
+ assert!(out.contains("\"thinking\":\"Working it out\""));
+ assert!(out.contains("event: message_stop"));
+ assert!(
+ out.find("\"type\":\"thinking_delta\"").unwrap()
+ < out.find("\"type\":\"text_delta\"").unwrap()
+ );
+ }
+
+ #[test]
+ fn stream_omits_empty_reasoning_summary() {
+ let upstream = format!(
+ "{}{}{}{}{}",
+ sse_event(
+ "response.output_item.added",
+ serde_json::json!({
+ "output_index":0,
+ "item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}
+ })
+ ),
+ sse_event(
+ "response.output_item.done",
+ serde_json::json!({
+ "output_index":0,
+ "item":{"type":"reasoning","summary":[],"encrypted_content":"enc"}
+ })
+ ),
+ sse_event(
+ "response.output_item.added",
+ serde_json::json!({
+ "output_index":1,
+ "item":{"type":"message","id":"msg_up"}
+ })
+ ),
+ sse_event(
+ "response.output_text.delta",
+ serde_json::json!({
+ "output_index":1,"delta":"answer"
+ })
+ ),
+ format!(
+ "{}{}",
+ sse_event(
+ "response.output_item.done",
+ serde_json::json!({
+ "output_index":1,"item":{"type":"message"}
+ })
+ ),
+ sse_event(
+ "response.completed",
+ serde_json::json!({
+ "response":{"id":"resp_1","usage":{}}
+ })
+ )
+ ),
+ );
+ let out = String::from_utf8(
+ translate_stream_bytes(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap(),
+ )
+ .unwrap();
+ assert!(!out.contains("\"type\":\"thinking\""));
+ assert!(!out.contains("\"type\":\"thinking_delta\""));
+ assert!(out.contains("event: message_stop"));
+ }
}