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.rsindex 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.rsindex 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 blocksif !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 blocksfor 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.rsindex 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>, Upstreamlet 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>, Upstreamcontinue;}+ 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>, Upstreamp.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.rsindex 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::ErroOk(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.rsindex 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"));+ }}