Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
perf(codex): cap reasoning effort on compaction requests (#67)
Kevin Lin80acd81738fe
diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rsindex 6c8674e..df664fe 100644--- a/src/providers/codex/translate/request.rs+++ b/src/providers/codex/translate/request.rs@@ -16,7 +16,7 @@ use super::reasoning_signature::decode_reasoning_signature;// Types// ----------------------------------------------------------------------------#[derive(Debug, Clone, Serialize, Deserialize)]+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]#[serde(rename_all = "snake_case")]pub enum Effort {None,@@ -266,6 +266,37 @@ fn reasoning_summary_requested(summary: Option<&str>) -> bool {!matches!(summary, Some("off" | "none"))}+// ---------------------------------------------------------------------------+// Compaction fast path+// ---------------------------------------------------------------------------++/// Stable marker Claude Code puts in the system prompt of every compaction+/// request (both manual `/compact` and auto-compact use the same prompt).+const COMPACT_SYSTEM_MARKER: &str =+ "You are a helpful AI assistant tasked with summarizing conversations";++fn is_compact_request(instructions: Option<&str>) -> bool {+ instructions.is_some_and(|text| text.contains(COMPACT_SYSTEM_MARKER))+}++/// Reasoning-effort cap applied to compaction requests, or None when the+/// fast path is disabled. Summarization is extraction, not problem solving:+/// native Claude Code compacts without extended thinking, so burning+/// medium/high reasoning on a 200k-token summary only adds latency. The cap+/// never raises effort — a request already below it is left alone.+fn compact_effort_cap() -> Option<Effort> {+ compact_effort_cap_from(std::env::var("CCP_COMPACT_EFFORT").ok().as_deref())+}++fn compact_effort_cap_from(raw: Option<&str>) -> Option<Effort> {+ match raw {+ None | Some("") => Some(Effort::Low),+ Some("off") => None,+ Some("none") => Some(Effort::None),+ Some(other) => to_codex_effort(Some(other)).or(Some(Effort::Low)),+ }+}+const VALID_SERVICE_TIERS: &[&str] = &["fast", "priority", "flex"];fn normalize_service_tier(tier: &str) -> Result<ServiceTier, anyhow::Error> {@@ -331,6 +362,7 @@ pub fn translate_request(opts: TranslateOptions,) -> Result<ResponsesRequest, anyhow::Error> {let instructions = flatten_system_text(req.extra.get("system"));+ let is_compact = is_compact_request(instructions.as_deref());let input = build_input(req);let tools = read_tools(req)?;let tool_choice = map_tool_choice(req)?;@@ -426,7 +458,13 @@ pub fn translate_request(let effort = read_effort(req)?;let codex_effort = to_codex_effort(effort);- let resolved_effort = resolve_effort(codex_effort)?;+ let mut resolved_effort = resolve_effort(codex_effort)?;+ if is_compact+ && let Some(cap) = compact_effort_cap()+ && resolved_effort.as_ref().is_some_and(|e| *e > cap)+ {+ resolved_effort = Some(cap);+ }if resolved_effort.is_some() || opts.use_responses_lite {let summary = if resolved_effort.is_some()&& reasoning_summary_requested(config::codex_reasoning_summary().as_deref())@@ -1274,6 +1312,87 @@ mod tests {assert!(matches!(effort, Some(Effort::Max)));}+ #[test]+ fn compact_request_detected_from_system_marker() {+ assert!(is_compact_request(Some(+ "You are a helpful AI assistant tasked with summarizing conversations."+ )));+ assert!(!is_compact_request(Some("You are Claude Code.")));+ assert!(!is_compact_request(None));+ }++ #[test]+ fn compact_effort_cap_parses_env_values() {+ assert!(matches!(compact_effort_cap_from(None), Some(Effort::Low)));+ assert!(matches!(+ compact_effort_cap_from(Some("")),+ Some(Effort::Low)+ ));+ assert!(compact_effort_cap_from(Some("off")).is_none());+ assert!(matches!(+ compact_effort_cap_from(Some("none")),+ Some(Effort::None)+ ));+ assert!(matches!(+ compact_effort_cap_from(Some("medium")),+ Some(Effort::Medium)+ ));+ // Unrecognized values fall back to the safe default.+ assert!(matches!(+ compact_effort_cap_from(Some("bogus")),+ Some(Effort::Low)+ ));+ }++ #[test]+ fn compact_request_downgrades_effort_to_cap() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"summarize"}],+ "system": "You are a helpful AI assistant tasked with summarizing conversations.",+ "output_config": {"effort": "medium"}+ }))+ .unwrap();+ let out = translate_request(&req, opts()).unwrap();+ assert!(matches!(out.reasoning.unwrap().effort, Some(Effort::Low)));+ }++ #[test]+ fn compact_cap_never_raises_effort() {+ // A compact request already at or below the cap is left alone.+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"summarize"}],+ "system": "You are a helpful AI assistant tasked with summarizing conversations.",+ "output_config": {"effort": "low"}+ }))+ .unwrap();+ let out = translate_request(&req, opts()).unwrap();+ assert!(matches!(out.reasoning.unwrap().effort, Some(Effort::Low)));+ }++ #[test]+ fn non_compact_request_keeps_requested_effort() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"hello"}],+ "system": "You are Claude Code.",+ "output_config": {"effort": "high"}+ }))+ .unwrap();+ let out = translate_request(&req, opts()).unwrap();+ assert!(matches!(out.reasoning.unwrap().effort, Some(Effort::High)));+ }++ #[test]+ fn effort_ordering_matches_variant_order() {+ assert!(Effort::None < Effort::Low);+ assert!(Effort::Low < Effort::Medium);+ assert!(Effort::Medium < Effort::High);+ assert!(Effort::High < Effort::Xhigh);+ assert!(Effort::Xhigh < Effort::Max);+ }+#[test]fn max_tokens_is_not_serialized_for_codex() {let req: MessagesRequest = serde_json::from_value(json!({