Skip to content

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

Rust

apply the compaction effort cap to requests naming no effort

Rik Brown6eb71861c5b7
diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rs
index 97fe55b..4c81140 100644
--- a/src/providers/codex/translate/request.rs
+++ b/src/providers/codex/translate/request.rs
@@ -352,10 +352,24 @@ pub(crate) fn is_compact_messages_request(request: &MessagesRequest) -> bool {
/// 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.
+///
+/// A request naming no effort at all also takes the cap. Left unset it would
+/// run at the upstream default, which is the effort level the cap exists to
+/// avoid.
fn compact_effort_cap() -> Option<Effort> {
compact_effort_cap_from(std::env::var("CCP_COMPACT_EFFORT").ok().as_deref())
}
+/// Applies the cap to a request's resolved effort. A missing effort takes
+/// the cap; an explicit effort at or below it is preserved.
+fn apply_compact_effort_cap(resolved: Option<Effort>, cap: Option<Effort>) -> Option<Effort> {
+ match (resolved, cap) {
+ (resolved, None) => resolved,
+ (Some(effort), Some(cap)) if effort <= cap => Some(effort),
+ (_, Some(cap)) => Some(cap),
+ }
+}
+
fn compact_effort_cap_from(raw: Option<&str>) -> Option<Effort> {
match raw {
None | Some("") => Some(Effort::Low),
@@ -559,12 +573,8 @@ fn translate_request_inner(
} else {
codex_effort
};
- if apply_codex_config
- && is_compact
- && let Some(cap) = compact_effort_cap()
- && resolved_effort.as_ref().is_some_and(|e| *e > cap)
- {
- resolved_effort = Some(cap);
+ if apply_codex_config && is_compact {
+ resolved_effort = apply_compact_effort_cap(resolved_effort, compact_effort_cap());
}
if resolved_effort.is_some() || opts.use_responses_lite {
let summary = if resolved_effort.is_some()
@@ -1892,6 +1902,39 @@ mod tests {
));
}
+ #[test]
+ fn compact_effort_cap_defaults_a_missing_effort() {
+ // No effort named: take the cap instead of the upstream default.
+ assert!(matches!(
+ apply_compact_effort_cap(None, Some(Effort::Low)),
+ Some(Effort::Low)
+ ));
+ assert!(matches!(
+ apply_compact_effort_cap(None, Some(Effort::None)),
+ Some(Effort::None)
+ ));
+ // An explicit effort at or below the cap survives.
+ assert!(matches!(
+ apply_compact_effort_cap(Some(Effort::None), Some(Effort::Low)),
+ Some(Effort::None)
+ ));
+ assert!(matches!(
+ apply_compact_effort_cap(Some(Effort::Low), Some(Effort::Low)),
+ Some(Effort::Low)
+ ));
+ // Above the cap is lowered.
+ assert!(matches!(
+ apply_compact_effort_cap(Some(Effort::High), Some(Effort::Low)),
+ Some(Effort::Low)
+ ));
+ // Cap disabled: the request is left exactly as it asked.
+ assert!(apply_compact_effort_cap(None, None).is_none());
+ assert!(matches!(
+ apply_compact_effort_cap(Some(Effort::High), None),
+ Some(Effort::High)
+ ));
+ }
+
#[test]
fn compact_request_downgrades_effort_to_cap() {
let req: MessagesRequest = serde_json::from_value(json!({