Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
add opt-in Codex server compaction
Raine Virtad33c82cbf64b
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex e4746d9..298ca30 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -1,5 +1,11 @@# Changelog+## Unreleased++- Codex optionally preserves conversation continuity across Claude Code+ compaction boundaries with native encrypted compaction artifacts. Enable it+ with `codex.serverCompaction` or `CCP_CODEX_SERVER_COMPACTION`.+## v0.1.23 (2026-07-22)- Codex WebSocket streaming handles pooled connections and HTTP fallback morediff --git a/README.md b/README.mdindex b8ecdb9..4a289e6 100644--- a/README.md+++ b/README.md@@ -283,6 +283,48 @@ so simple prompts can emit no thinking block. Set `codex.reasoningSummary` /`CCP_CODEX_REASONING_SUMMARY` to `off` or `none` to suppress summaries whilekeeping `reasoning.effort` and encrypted continuation content.+#### Server compaction++Codex server compaction is disabled by default. Enable it for the proxy process+with either configuration form:++```json+{+ "codex": {+ "serverCompaction": true+ }+}+```++```sh+CCP_CODEX_SERVER_COMPACTION=1 claude-code-proxy serve+```++When Claude Code reaches a manual or automatic compaction boundary, the proxy:++1. Sends the translated Codex conversation with a trailing+ `compaction_trigger`. The request uses the selected Responses lane and omits+ Claude Code's summarization instruction.+2. Stores the encrypted `compaction` item returned by Codex in memory for the+ matching Claude Code session and model.+3. Allows Claude Code's normal portable summary request to complete and uses+ that summary as an exact replay anchor.+4. Replaces the anchored portable summary on subsequent Codex turns with recent+ retained messages, the encrypted compaction item, and messages added after+ the boundary.++This gives Codex its native compacted conversation while preserving Claude+Code's portable summary as a fallback. Replay requires append-only history in+the same session and model. A branch, proxy restart, provider or model change,+malformed response, upstream failure, expired state, or memory limit uses the+portable history instead. Compaction state remains in memory for up to 30+minutes.++The boundary performs one additional Codex request, so `/compact` can take+longer. Structured log events named `server_compaction_triggered`,+`server_compaction_completed`, and `server_compaction_failed` expose each+attempt and outcome.+Claude Code's hosted `web_search_20250305` tool is translated to Codex's nativeResponses `web_search` tool with live external web access and non-empty nativedomain filters. Forced searches use Codex's required `allowed_tools` form so@@ -692,7 +734,8 @@ Windows, and at"serviceTier": "fast","baseUrl": "https://chatgpt.com/backend-api/codex/responses","transport": "websocket",- "previousResponseId": false+ "previousResponseId": false,+ "serverCompaction": true},"kimi": {"userAgent": "KimiCLI/1.37.0",@@ -734,6 +777,7 @@ Windows, and at| `CCP_CODEX_BASE_URL` | `codex.baseUrl` | `https://chatgpt.com/backend-api/codex/responses` | Override the Codex Responses endpoint || `CCP_CODEX_TRANSPORT` | `codex.transport` | `websocket` | Codex transport: `websocket`, `http`, or `auto` || `CCP_CODEX_PREVIOUS_RESPONSE_ID` | `codex.previousResponseId` | `false` | Enable WebSocket continuation with `previous_response_id` when the request is append-only |+| `CCP_CODEX_SERVER_COMPACTION` | `codex.serverCompaction` | `false` | Enable Codex remote compaction at Claude Code compaction boundaries with `1`, `true`, `yes`, or `on` || `CCP_CODEX_ORIGINATOR` | `codex.originator` | `claude-code-proxy` | Override the `originator` header sent to Codex || `CCP_CODEX_USER_AGENT` | `codex.userAgent` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex || `CCP_KIMI_USER_AGENT` | `kimi.userAgent` | `KimiCLI/1.37.0` | Override the `User-Agent` header sent to Kimi |diff --git a/src/config.rs b/src/config.rsindex df1b028..5c0c3ae 100644--- a/src/config.rs+++ b/src/config.rs@@ -54,6 +54,8 @@ struct CodexConfig {pub user_agent: Option<String>,#[serde(rename = "previousResponseId")]pub previous_response_id: Option<bool>,+ #[serde(rename = "serverCompaction")]+ pub server_compaction: Option<bool>,#[serde(rename = "serviceTier")]pub service_tier: Option<String>,#[serde(rename = "reasoningSummary")]@@ -244,6 +246,9 @@ pub fn config_override_summary_lines(cfg: &LoadedConfig) -> Vec<String> {{out.push("CCP_CODEX_REASONING_SUMMARY (env)".to_string());}+ if env.contains_key("CCP_CODEX_SERVER_COMPACTION") {+ out.push("CCP_CODEX_SERVER_COMPACTION (env)".to_string());+ }if let Some(file_cfg) = file {if let Some(bind_address) = file_cfg.bind_address {out.push(format!("bindAddress: {bind_address}"));@@ -262,11 +267,16 @@ 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());+ if let Some(codex) = file_cfg.codex {+ if codex+ .reasoning_summary+ .is_some_and(|value| !value.is_empty())+ {+ out.push("codex.reasoningSummary (config)".to_string());+ }+ if let Some(enabled) = codex.server_compaction {+ out.push(format!("codex.serverCompaction: {enabled}"));+ }}}out@@ -420,6 +430,25 @@ pub fn codex_previous_response_id() -> bool {false}+pub fn codex_server_compaction() -> bool {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_SERVER_COMPACTION") {+ match raw.trim().to_ascii_lowercase().as_str() {+ "1" | "true" | "yes" | "on" => return true,+ "0" | "false" | "no" | "off" => return false,+ _ => {}+ }+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir)+ && let Some(codex) = file.codex+ && let Some(enabled) = codex.server_compaction+ {+ return enabled;+ }+ false+}+pub fn codex_service_tier() -> Option<String> {let env: HashMap<_, _> = std::env::vars().collect();if let Some(raw) = env.get("CCP_CODEX_SERVICE_TIER") {@@ -592,6 +621,7 @@ mod tests {std::env::remove_var("CCP_LOG_VERBOSE");std::env::remove_var("CCP_LOG_STDERR");std::env::remove_var("CCP_CODEX_REASONING_SUMMARY");+ std::env::remove_var("CCP_CODEX_SERVER_COMPACTION");}}@@ -782,4 +812,26 @@ mod tests {assert_eq!(codex_reasoning_summary().as_deref(), Some("off"));}}++ #[test]+ fn codex_server_compaction_defaults_and_overrides() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ let config = tempfile::TempDir::new().unwrap();+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());++ assert!(!codex_server_compaction());+ {+ let _enabled_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "on");+ assert!(codex_server_compaction());+ }+ std::fs::write(+ config.path().join("config.json"),+ r#"{"codex":{"serverCompaction":true}}"#,+ )+ .unwrap();+ assert!(codex_server_compaction());+ let _disabled_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "false");+ assert!(!codex_server_compaction());+ }}diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 9d57775..df08ba1 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -121,6 +121,10 @@ pub fn build_codex_headers("openai-beta",header_value("openai-beta", "responses=experimental")?,);+ headers.insert(+ "x-codex-beta-features",+ header_value("x-codex-beta-features", "remote_compaction_v2")?,+ );if use_responses_lite {headers.insert("x-openai-internal-codex-responses-lite",@@ -1701,6 +1705,10 @@ mod tests {"responses=experimental");assert_eq!(headers.get("session_id").unwrap(), "s");+ assert_eq!(+ headers.get("x-codex-beta-features").unwrap(),+ "remote_compaction_v2"+ );}#[test]diff --git a/src/providers/codex/compaction.rs b/src/providers/codex/compaction.rsnew file mode 100644index 0000000..dba2733--- /dev/null+++ b/src/providers/codex/compaction.rs@@ -0,0 +1,719 @@+use std::collections::HashMap;+use std::sync::Mutex;+use std::time::{SystemTime, UNIX_EPOCH};++use crate::anthropic::sse::parse_sse_events;+use crate::provider::RequestContext;+use crate::providers::codex::client::{CodexError, CodexHttpClient};++use super::translate::request::{+ ResponsesContentPart, ResponsesInputItem, ResponsesRequest, is_compact_message_text,+};++const RETAINED_MESSAGE_TOKEN_BUDGET: u64 = 20_000;+const STATE_TTL_MS: u64 = 30 * 60 * 1_000;+const MAX_STATES: usize = 1_000;+const MAX_STATE_BYTES: usize = 4 * 1024 * 1024;+const MAX_TOTAL_STATE_BYTES: usize = 20_000_000;+const MIN_PORTABLE_SUMMARY_BYTES: usize = 32;++#[derive(Debug)]+pub enum CompactionError {+ Upstream(CodexError),+ InvalidResponse(String),+}++impl std::fmt::Display for CompactionError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ Self::Upstream(error) => write!(f, "{error}"),+ Self::InvalidResponse(message) => f.write_str(message),+ }+ }+}++enum CompactionPhase {+ Unconfirmed,+ Anchored { portable_summary: String },+}++struct CompactionState {+ model: String,+ native_history: Vec<ResponsesInputItem>,+ phase: CompactionPhase,+ updated_at: u64,+}++#[derive(Default)]+struct CompactionRegistry {+ states: HashMap<String, CompactionState>,+ total_bytes: usize,+}++static REGISTRY: Mutex<Option<CompactionRegistry>> = Mutex::new(None);++pub async fn request_compaction(+ client: &CodexHttpClient,+ request: &ResponsesRequest,+ ctx: &RequestContext,+) -> Result<Vec<ResponsesInputItem>, CompactionError> {+ let (envelope, conversation) = split_input_envelope(&request.input);+ let conversation = without_compaction_instruction(conversation);+ let mut compaction_request = request.clone();+ compaction_request.instructions = None;+ compaction_request.input = envelope+ .iter()+ .filter(|item| matches!(item, ResponsesInputItem::AdditionalTools { .. }))+ .cloned()+ .chain(conversation.iter().cloned())+ .chain(std::iter::once(ResponsesInputItem::CompactionTrigger))+ .collect();+ compaction_request.include = Some(vec!["reasoning.encrypted_content".to_string()]);++ let response = client+ .post_codex(&compaction_request, ctx, None)+ .await+ .map_err(CompactionError::Upstream)?;+ let compaction = parse_compaction_response(&response.body)?;+ Ok(build_compacted_history(&conversation, compaction))+}++pub fn store_compaction(+ session_id: &str,+ model: &str,+ native_history: Vec<ResponsesInputItem>,+) -> bool {+ let state = CompactionState {+ model: model.to_string(),+ native_history,+ phase: CompactionPhase::Unconfirmed,+ updated_at: now_ms(),+ };+ if state_size(session_id, &state) > MAX_STATE_BYTES {+ clear_compaction(session_id);+ return false;+ }++ let now = state.updated_at;+ let mut guard = REGISTRY.lock().unwrap();+ let registry = guard.get_or_insert_with(CompactionRegistry::default);+ evict_states(registry, now);+ registry.states.insert(session_id.to_string(), state);+ evict_states(registry, now);+ registry.states.contains_key(session_id)+}++pub fn activate_compaction(+ session_id: Option<&str>,+ model: &str,+ output: &[ResponsesInputItem],+) -> bool {+ let Some(session_id) = session_id else {+ return false;+ };+ let Some(portable_summary) = portable_summary_text(output) else {+ clear_compaction(session_id);+ return false;+ };++ let now = now_ms();+ let mut guard = REGISTRY.lock().unwrap();+ let Some(registry) = guard.as_mut() else {+ return false;+ };+ evict_states(registry, now);+ let Some(state) = registry.states.get_mut(session_id) else {+ return false;+ };+ if state.model != model || !matches!(state.phase, CompactionPhase::Unconfirmed) {+ registry.states.remove(session_id);+ update_total_bytes(registry);+ return false;+ }+ state.phase = CompactionPhase::Anchored { portable_summary };+ state.updated_at = now;+ if state_size(session_id, state) > MAX_STATE_BYTES {+ registry.states.remove(session_id);+ update_total_bytes(registry);+ return false;+ }+ evict_states(registry, now);+ registry.states.contains_key(session_id)+}++pub fn apply_compaction_replay(+ session_id: Option<&str>,+ request: &ResponsesRequest,+) -> Option<ResponsesRequest> {+ let session_id = session_id?;+ let now = now_ms();+ let mut guard = REGISTRY.lock().unwrap();+ let registry = guard.as_mut()?;+ evict_states(registry, now);+ let state = registry.states.get_mut(session_id)?;+ if state.model != request.model {+ registry.states.remove(session_id);+ update_total_bytes(registry);+ return None;+ }+ let CompactionPhase::Anchored { portable_summary } = &state.phase else {+ return None;+ };++ let (envelope, conversation) = split_input_envelope(&request.input);+ let Some(summary_item) = conversation.first() else {+ return None;+ };+ let Some(text) = message_text(summary_item) else {+ registry.states.remove(session_id);+ update_total_bytes(registry);+ return None;+ };+ if text.match_indices(portable_summary).count() != 1 {+ registry.states.remove(session_id);+ update_total_bytes(registry);+ return None;+ }+ if conversation.len() == 1 {+ return None;+ }++ let mut replay = request.clone();+ replay.input = envelope+ .iter()+ .cloned()+ .chain(state.native_history.iter().cloned())+ .chain(conversation[1..].iter().cloned())+ .collect();+ if serialized_size(&replay.input) > MAX_STATE_BYTES {+ registry.states.remove(session_id);+ update_total_bytes(registry);+ return None;+ }+ state.updated_at = now;+ Some(replay)+}++pub fn abort_compaction_attempt(+ session_id: Option<&str>,+ compact_boundary: bool,+ request: &ResponsesRequest,+) {+ if compact_boundary || request_contains_compaction(request) {+ if let Some(session_id) = session_id {+ clear_compaction(session_id);+ }+ }+}++pub fn request_contains_compaction(request: &ResponsesRequest) -> bool {+ request+ .input+ .iter()+ .any(|item| matches!(item, ResponsesInputItem::Compaction { .. }))+}++pub fn clear_compaction(session_id: &str) {+ let mut guard = REGISTRY.lock().unwrap();+ if let Some(registry) = guard.as_mut() {+ registry.states.remove(session_id);+ update_total_bytes(registry);+ }+}++fn split_input_envelope(+ input: &[ResponsesInputItem],+) -> (&[ResponsesInputItem], &[ResponsesInputItem]) {+ let prefix_len = input+ .iter()+ .take_while(|item| is_envelope_item(item))+ .count();+ input.split_at(prefix_len)+}++fn without_compaction_instruction(input: &[ResponsesInputItem]) -> Vec<ResponsesInputItem> {+ let mut input = input.to_vec();+ let remove_empty_message = if let Some(ResponsesInputItem::Message { role, content }) =+ input.last_mut()+ && role == "user"+ {+ content.retain(|part| {+ !matches!(+ part,+ ResponsesContentPart::InputText { text }+ if is_compact_message_text(text)+ )+ });+ content.is_empty()+ } else {+ false+ };+ if remove_empty_message {+ input.pop();+ }+ input+}++fn is_envelope_item(item: &ResponsesInputItem) -> bool {+ match item {+ ResponsesInputItem::AdditionalTools { .. } => true,+ ResponsesInputItem::Message { role, .. } => role == "developer",+ _ => false,+ }+}++fn portable_summary_text(output: &[ResponsesInputItem]) -> Option<String> {+ let text = output+ .iter()+ .filter_map(|item| match item {+ ResponsesInputItem::Message { role, content } if role == "assistant" => Some(content),+ _ => None,+ })+ .flat_map(|content| content.iter())+ .filter_map(|part| match part {+ ResponsesContentPart::InputText { text }+ | ResponsesContentPart::OutputText { text } => Some(text.as_str()),+ ResponsesContentPart::InputImage { .. } => None,+ })+ .collect::<String>();+ let trimmed = text.trim();+ let summary = trimmed+ .split_once("<summary>")+ .and_then(|(_, rest)| rest.split_once("</summary>"))+ .map(|(summary, _)| summary.trim())+ .filter(|summary| !summary.is_empty())+ .unwrap_or(trimmed);+ (summary.len() >= MIN_PORTABLE_SUMMARY_BYTES).then(|| summary.to_string())+}++fn message_text(item: &ResponsesInputItem) -> Option<String> {+ let ResponsesInputItem::Message { content, .. } = item else {+ return None;+ };+ Some(+ content+ .iter()+ .filter_map(|part| match part {+ ResponsesContentPart::InputText { text }+ | ResponsesContentPart::OutputText { text } => Some(text.as_str()),+ ResponsesContentPart::InputImage { .. } => None,+ })+ .collect(),+ )+}++fn parse_compaction_response(body: &[u8]) -> Result<ResponsesInputItem, CompactionError> {+ let mut completed = false;+ let mut compacted = Vec::new();++ for event in parse_sse_events(body) {+ if event.data == "[DONE]" {+ continue;+ }+ let Ok(payload) = serde_json::from_str::<serde_json::Value>(&event.data) else {+ continue;+ };+ match payload.get("type").and_then(serde_json::Value::as_str) {+ Some("error" | "response.error" | "response.failed") => {+ let message = payload+ .pointer("/response/error/message")+ .or_else(|| payload.pointer("/error/message"))+ .or_else(|| payload.get("message"))+ .and_then(serde_json::Value::as_str)+ .unwrap_or("remote compaction failed");+ return Err(CompactionError::InvalidResponse(message.to_string()));+ }+ Some("response.output_item.done") => {+ let Some(item) = payload.get("item") else {+ continue;+ };+ if item.get("type").and_then(serde_json::Value::as_str) == Some("compaction")+ && let Some(encrypted_content) = item+ .get("encrypted_content")+ .and_then(serde_json::Value::as_str)+ {+ compacted.push(ResponsesInputItem::Compaction {+ encrypted_content: encrypted_content.to_string(),+ });+ }+ }+ Some("response.completed") => completed = true,+ _ => {}+ }+ }++ if !completed {+ return Err(CompactionError::InvalidResponse(+ "remote compaction stream ended before response.completed".to_string(),+ ));+ }+ if compacted.len() != 1 {+ return Err(CompactionError::InvalidResponse(format!(+ "remote compaction expected exactly one compaction item, got {}",+ compacted.len()+ )));+ }+ Ok(compacted.pop().expect("validated one compaction item"))+}++fn build_compacted_history(+ input: &[ResponsesInputItem],+ compaction: ResponsesInputItem,+) -> Vec<ResponsesInputItem> {+ let retained = input+ .iter()+ .filter(|item| {+ matches!(+ item,+ ResponsesInputItem::Message { role, .. }+ if matches!(role.as_str(), "user" | "developer" | "system")+ )+ })+ .cloned()+ .collect::<Vec<_>>();+ let mut retained = truncate_retained_messages(retained, RETAINED_MESSAGE_TOKEN_BUDGET);+ retained.push(compaction);+ retained+}++fn truncate_retained_messages(+ items: Vec<ResponsesInputItem>,+ max_tokens: u64,+) -> Vec<ResponsesInputItem> {+ let mut remaining = max_tokens;+ let mut retained = Vec::new();+ for item in items.into_iter().rev() {+ if remaining == 0 {+ break;+ }+ let tokens = message_tokens(&item).max(1);+ if tokens <= remaining {+ retained.push(item);+ remaining -= tokens;+ } else if let Some(item) = truncate_message(item, remaining) {+ retained.push(item);+ remaining = 0;+ }+ }+ retained.reverse();+ retained+}++fn message_tokens(item: &ResponsesInputItem) -> u64 {+ let ResponsesInputItem::Message { content, .. } = item else {+ return 0;+ };+ content+ .iter()+ .map(|part| match part {+ ResponsesContentPart::InputText { text }+ | ResponsesContentPart::OutputText { text } => text.len().div_ceil(4) as u64,+ ResponsesContentPart::InputImage { .. } => 2_000,+ })+ .sum()+}++fn truncate_message(item: ResponsesInputItem, max_tokens: u64) -> Option<ResponsesInputItem> {+ let ResponsesInputItem::Message { role, content } = item else {+ return Some(item);+ };+ let mut remaining_chars = max_tokens.saturating_mul(4) as usize;+ let mut truncated = Vec::new();+ for part in content {+ match part {+ ResponsesContentPart::InputImage { .. } => truncated.push(part),+ ResponsesContentPart::InputText { text } => {+ let text = truncate_text(text, &mut remaining_chars);+ if !text.is_empty() {+ truncated.push(ResponsesContentPart::InputText { text });+ }+ }+ ResponsesContentPart::OutputText { text } => {+ let text = truncate_text(text, &mut remaining_chars);+ if !text.is_empty() {+ truncated.push(ResponsesContentPart::OutputText { text });+ }+ }+ }+ }+ (!truncated.is_empty()).then_some(ResponsesInputItem::Message {+ role,+ content: truncated,+ })+}++fn truncate_text(mut text: String, remaining_chars: &mut usize) -> String {+ if *remaining_chars == 0 {+ return String::new();+ }+ if text.len() > *remaining_chars {+ let mut boundary = *remaining_chars;+ while !text.is_char_boundary(boundary) {+ boundary -= 1;+ }+ text.truncate(boundary);+ }+ *remaining_chars -= text.len();+ text+}++fn serialized_size(items: &[ResponsesInputItem]) -> usize {+ serde_json::to_vec(items).map_or(usize::MAX, |value| value.len())+}++fn state_size(session_id: &str, state: &CompactionState) -> usize {+ let summary_len = match &state.phase {+ CompactionPhase::Unconfirmed => 0,+ CompactionPhase::Anchored { portable_summary } => portable_summary.len(),+ };+ session_id.len() + state.model.len() + summary_len + serialized_size(&state.native_history)+}++fn now_ms() -> u64 {+ SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .unwrap_or_default()+ .as_millis() as u64+}++fn update_total_bytes(registry: &mut CompactionRegistry) {+ registry.total_bytes = registry+ .states+ .iter()+ .map(|(session_id, state)| state_size(session_id, state))+ .sum();+}++fn evict_states(registry: &mut CompactionRegistry, now: u64) {+ registry+ .states+ .retain(|_, state| now.saturating_sub(state.updated_at) <= STATE_TTL_MS);+ update_total_bytes(registry);+ while registry.states.len() > MAX_STATES || registry.total_bytes > MAX_TOTAL_STATE_BYTES {+ let oldest = registry+ .states+ .iter()+ .min_by_key(|(_, state)| state.updated_at)+ .map(|(session_id, _)| session_id.clone());+ let Some(oldest) = oldest else {+ break;+ };+ registry.states.remove(&oldest);+ update_total_bytes(registry);+ }+}++pub fn clear_all_compactions_for_tests() {+ *REGISTRY.lock().unwrap() = None;+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ const SUMMARY: &str =+ "portable summary with enough detail to identify this compacted conversation";+ static TEST_REGISTRY_LOCK: Mutex<()> = Mutex::new(());++ fn request(input: serde_json::Value) -> ResponsesRequest {+ serde_json::from_value(json!({+ "model": "gpt-5.6-sol",+ "input": input,+ "store": false,+ "stream": true,+ "parallel_tool_calls": false,+ "client_metadata": {"lite":"true"},+ "text": {"verbosity":"low"}+ }))+ .unwrap()+ }++ fn output(text: &str) -> Vec<ResponsesInputItem> {+ serde_json::from_value(json!([{+ "type":"message",+ "role":"assistant",+ "content":[{"type":"output_text","text":text}]+ }]))+ .unwrap()+ }++ #[test]+ fn parses_exactly_one_completed_compaction_item() {+ let body = b"data: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"compaction\",\"encrypted_content\":\"opaque\"}}\n\ndata: {\"type\":\"response.completed\",\"response\":{}}\n\n";+ assert!(matches!(+ parse_compaction_response(body).unwrap(),+ ResponsesInputItem::Compaction { encrypted_content } if encrypted_content == "opaque"+ ));+ }++ #[test]+ fn rejects_incomplete_or_ambiguous_compaction_streams() {+ let incomplete = b"data: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"compaction\",\"encrypted_content\":\"opaque\"}}\n\n";+ assert!(+ parse_compaction_response(incomplete)+ .unwrap_err()+ .to_string()+ .contains("before response.completed")+ );+ let missing = b"data: {\"type\":\"response.completed\",\"response\":{}}\n\n";+ assert!(+ parse_compaction_response(missing)+ .unwrap_err()+ .to_string()+ .contains("exactly one")+ );+ }++ #[test]+ fn replay_requires_activation_and_wrapped_summary_anchor() {+ let _guard = TEST_REGISTRY_LOCK.lock().unwrap();+ clear_all_compactions_for_tests();+ store_compaction(+ "session",+ "gpt-5.6-sol",+ vec![ResponsesInputItem::Compaction {+ encrypted_content: "opaque".to_string(),+ }],+ );+ let next = request(json!([+ {"type":"additional_tools","role":"developer","tools":[]},+ {"type":"message","role":"developer","content":[{"type":"input_text","text":"instructions"}]},+ {"type":"message","role":"user","content":[{"type":"input_text","text":format!("<summary>{SUMMARY}</summary>")}]},+ {"type":"message","role":"user","content":[{"type":"input_text","text":"continue"}]}+ ]));+ assert!(apply_compaction_replay(Some("session"), &next).is_none());+ assert!(activate_compaction(+ Some("session"),+ "gpt-5.6-sol",+ &output(&format!(+ "<analysis>summary preparation</analysis>\n<summary>\n{SUMMARY}\n</summary>"+ ))+ ));++ let replay = apply_compaction_replay(Some("session"), &next).unwrap();+ assert!(matches!(+ replay.input[0],+ ResponsesInputItem::AdditionalTools { .. }+ ));+ assert!(+ matches!(replay.input[1], ResponsesInputItem::Message { ref role, .. } if role == "developer")+ );+ assert!(matches!(+ replay.input[2],+ ResponsesInputItem::Compaction { .. }+ ));+ assert_eq!(replay.client_metadata, next.client_metadata);+ }++ #[test]+ fn replay_clears_on_missing_or_duplicate_anchor() {+ let _guard = TEST_REGISTRY_LOCK.lock().unwrap();+ for text in [+ "different conversation without the expected summary".to_string(),+ format!("{SUMMARY} and {SUMMARY}"),+ ] {+ clear_all_compactions_for_tests();+ store_compaction(+ "session",+ "gpt-5.6-sol",+ vec![ResponsesInputItem::Compaction {+ encrypted_content: "opaque".to_string(),+ }],+ );+ activate_compaction(Some("session"), "gpt-5.6-sol", &output(SUMMARY));+ let changed = request(json!([+ {"type":"message","role":"user","content":[{"type":"input_text","text":text}]},+ {"type":"message","role":"user","content":[{"type":"input_text","text":"continue"}]}+ ]));+ assert!(apply_compaction_replay(Some("session"), &changed).is_none());+ assert!(apply_compaction_replay(Some("session"), &changed).is_none());+ }+ }++ #[test]+ fn compacted_history_excludes_lite_envelope() {+ let input: Vec<ResponsesInputItem> = serde_json::from_value(json!([+ {"type":"additional_tools","role":"developer","tools":[]},+ {"type":"message","role":"developer","content":[{"type":"input_text","text":"summarize"}]},+ {"type":"message","role":"user","content":[{"type":"input_text","text":"remember me"}]}+ ])).unwrap();+ let (_, conversation) = split_input_envelope(&input);+ let history = build_compacted_history(+ conversation,+ ResponsesInputItem::Compaction {+ encrypted_content: "opaque".to_string(),+ },+ );+ assert_eq!(history.len(), 2);+ assert!(+ matches!(history[0], ResponsesInputItem::Message { ref role, .. } if role == "user")+ );+ }++ #[test]+ fn failed_replay_clears_anchored_state() {+ let _guard = TEST_REGISTRY_LOCK.lock().unwrap();+ clear_all_compactions_for_tests();+ store_compaction(+ "failed-replay",+ "gpt-5.6-sol",+ vec![ResponsesInputItem::Compaction {+ encrypted_content: "opaque".to_string(),+ }],+ );+ activate_compaction(Some("failed-replay"), "gpt-5.6-sol", &output(SUMMARY));+ let next = request(json!([+ {"type":"message","role":"user","content":[{"type":"input_text","text":SUMMARY}]},+ {"type":"message","role":"user","content":[{"type":"input_text","text":"continue"}]}+ ]));+ let replay = apply_compaction_replay(Some("failed-replay"), &next).unwrap();++ abort_compaction_attempt(Some("failed-replay"), false, &replay);++ assert!(apply_compaction_replay(Some("failed-replay"), &next).is_none());+ }++ #[test]+ fn replay_clears_on_model_change() {+ let _guard = TEST_REGISTRY_LOCK.lock().unwrap();+ clear_all_compactions_for_tests();+ store_compaction(+ "session",+ "gpt-5.6-sol",+ vec![ResponsesInputItem::Compaction {+ encrypted_content: "opaque".to_string(),+ }],+ );+ activate_compaction(Some("session"), "gpt-5.6-sol", &output(SUMMARY));+ let mut changed = request(json!([+ {"type":"message","role":"user","content":[{"type":"input_text","text":SUMMARY}]},+ {"type":"message","role":"user","content":[{"type":"input_text","text":"continue"}]}+ ]));+ changed.model = "gpt-5.4".to_string();+ assert!(apply_compaction_replay(Some("session"), &changed).is_none());+ }++ #[test]+ fn retained_history_obeys_token_budget_at_utf8_boundary() {+ let text = "é".repeat((RETAINED_MESSAGE_TOKEN_BUDGET as usize + 10) * 4);+ let input: Vec<ResponsesInputItem> = serde_json::from_value(json!([+ {"type":"message","role":"user","content":[{"type":"input_text","text":text}]}+ ]))+ .unwrap();+ let history = build_compacted_history(+ &input,+ ResponsesInputItem::Compaction {+ encrypted_content: "opaque".to_string(),+ },+ );+ let ResponsesInputItem::Message { content, .. } = &history[0] else {+ panic!("expected retained message");+ };+ let ResponsesContentPart::InputText { text } = &content[0] else {+ panic!("expected retained text");+ };+ assert!(text.len() <= RETAINED_MESSAGE_TOKEN_BUDGET as usize * 4);+ assert!(std::str::from_utf8(text.as_bytes()).is_ok());+ }+}diff --git a/src/providers/codex/count_tokens.rs b/src/providers/codex/count_tokens.rsindex b2982bb..580e7d8 100644--- a/src/providers/codex/count_tokens.rs+++ b/src/providers/codex/count_tokens.rs@@ -55,7 +55,11 @@ fn count_input_item_tokens(item: &ResponsesInputItem) -> u64 {}ResponsesInputItem::Reasoning {encrypted_content, ..- } => approx_reasoning_token_count(encrypted_content),+ }+ | ResponsesInputItem::Compaction { encrypted_content } => {+ approx_reasoning_token_count(encrypted_content)+ }+ ResponsesInputItem::CompactionTrigger => 0,}}diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex b9b6a50..8a4d742 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -1,5 +1,6 @@pub mod auth;pub mod client;+pub mod compaction;pub mod continuation;pub mod count_tokens;pub(crate) mod events;@@ -18,6 +19,7 @@ use std::sync::Arc;use crate::anthropic::error::json_error;use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};use crate::config;+use crate::logging::create_logger;use crate::monitor::usage_from_anthropic_sse;use crate::provider::{CliHandlers, Provider, RequestContext};use crate::registry;@@ -28,6 +30,10 @@ use self::auth::device::DeviceAuthClient;use self::auth::manager::CodexAuthManager;use self::auth::token_store::file_store;use self::client::CodexHttpClient;+use self::compaction::{+ abort_compaction_attempt, activate_compaction, apply_compaction_replay, request_compaction,+ store_compaction,+};use self::continuation::{ContinuationCandidate, abort_continuation, continuation_candidate, record_continuation,};@@ -38,7 +44,9 @@ use self::translate::model_allowlist::{assert_allowed_model, full_lane_web_search_model, resolve_model_request, uses_responses_lite,};use self::translate::reducer::finish_metadata_from_upstream;-use self::translate::request::{TranslateOptions, has_hosted_web_search, translate_request};+use self::translate::request::{+ TranslateOptions, has_hosted_web_search, is_compact_messages_request, translate_request,+};const MAX_RETRYABLE_LIVE_STREAM_RETRIES: u32 = 10;use self::translate::stream::translate_stream_bytes_with_traffic;@@ -47,6 +55,10 @@ use self::translate::stream::translate_stream_bytes_with_traffic;// Provider// ---------------------------------------------------------------------------+pub(crate) fn clear_session_compaction(session_id: &str) {+ compaction::clear_compaction(session_id);+}+pub struct CodexProvider {client: Arc<CodexHttpClient>,}@@ -109,7 +121,7 @@ impl Provider for CodexProvider {monitor.model_resolved(&ctx.req_id, &resolved.model);}- let translated = match translate_request(+ let mut translated = match translate_request(&body,TranslateOptions {session_id: ctx.session_id.clone(),@@ -128,6 +140,59 @@ impl Provider for CodexProvider {}};+ let compact_boundary = is_compact_messages_request(&body);+ let server_compaction_enabled = config::codex_server_compaction();+ if !server_compaction_enabled && let Some(session_id) = ctx.session_id.as_deref() {+ compaction::clear_compaction(session_id);+ }+ if server_compaction_enabled+ && compact_boundary+ && let Some(session_id) = ctx.session_id.as_deref()+ {+ compaction::clear_compaction(session_id);+ log_compaction_event(+ "server_compaction_triggered",+ &ctx,+ translated.input.len(),+ None,+ );+ let mut compaction_ctx = ctx.clone();+ compaction_ctx.monitor = None;+ match request_compaction(self.client.as_ref(), &translated, &compaction_ctx).await {+ Ok(native_history) => {+ if store_compaction(session_id, &translated.model, native_history) {+ log_compaction_event(+ "server_compaction_completed",+ &ctx,+ translated.input.len(),+ None,+ );+ } else {+ log_compaction_event(+ "server_compaction_failed",+ &ctx,+ translated.input.len(),+ Some("compaction state exceeded the in-memory limit"),+ );+ }+ }+ Err(error) => {+ compaction::clear_compaction(session_id);+ log_compaction_event(+ "server_compaction_failed",+ &ctx,+ translated.input.len(),+ Some(&error.to_string()),+ );+ }+ }+ } else if server_compaction_enabled+ && !compact_boundary+ && let Some(replay) = apply_compaction_replay(ctx.session_id.as_deref(), &translated)+ {+ translated = replay;+ }+// Check continuationlet previous_response_id_enabled = config::codex_previous_response_id();let continuation = continuation_candidate(@@ -151,6 +216,7 @@ impl Provider for CodexProvider {ctx,stream_request,continuation,+ compact_boundary,).await;}@@ -161,6 +227,7 @@ impl Provider for CodexProvider {{Ok(r) => r,Err(e) => {+ abort_compaction_attempt(ctx.session_id.as_deref(), compact_boundary, &translated);abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&e);}@@ -175,6 +242,11 @@ impl Provider for CodexProvider {) {Ok(b) => b,Err(e) => {+ abort_compaction_attempt(+ ctx.session_id.as_deref(),+ compact_boundary,+ &translated,+ );abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_failure_to_response(&format!("Stream translation error: {e}"@@ -196,6 +268,7 @@ impl Provider for CodexProvider {turn_id,&translated,&upstream.body,+ compact_boundary,);let headers = [@@ -225,10 +298,16 @@ impl Provider for CodexProvider {turn_id,&translated,&upstream.body,+ compact_boundary,);(StatusCode::OK, Json(json)).into_response()}Err(e) => {+ abort_compaction_attempt(+ ctx.session_id.as_deref(),+ compact_boundary,+ &translated,+ );abort_continuation(ctx.session_id.as_deref(), turn_id);map_codex_failure_to_response(&format!("Accumulation error: {e}"))}@@ -303,6 +382,33 @@ fn count_sse_events(bytes: &[u8]) -> u64 {String::from_utf8_lossy(bytes).matches("event:").count() as u64}+fn log_compaction_event(+ event: &str,+ ctx: &RequestContext,+ input_items: usize,+ error: Option<&str>,+) {+ let mut fields = serde_json::Map::new();+ fields.insert("reqId".into(), serde_json::json!(ctx.req_id));+ fields.insert("inputItems".into(), serde_json::json!(input_items));+ if let Some(error) = error {+ fields.insert("error".into(), serde_json::json!(error));+ create_logger("codex").warn(event, Some(fields));+ } else {+ create_logger("codex").info(event, Some(fields));+ }+}++fn abort_request_state(+ session_id: Option<&str>,+ turn_id: Option<u64>,+ compact_boundary: bool,+ request: &translate::request::ResponsesRequest,+) {+ abort_compaction_attempt(session_id, compact_boundary, request);+ abort_continuation(session_id, turn_id);+}+enum LiveStreamStart {Response(Response),Retry { error: client::CodexError },@@ -315,6 +421,7 @@ async fn live_stream_response(ctx: RequestContext,request_body: translate::request::ResponsesRequest,continuation: ContinuationCandidate,+ compact_boundary: bool,) -> Response {let model = model.to_string();let turn_id = continuation.turn_id;@@ -334,12 +441,22 @@ async fn live_stream_response(continue;}if attempt >= MAX_RETRYABLE_LIVE_STREAM_RETRIES {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return map_codex_error_to_response(&err);}let delay = compute_backoff_delay(attempt, err.retry_after.as_deref());if delay.exceeds_budget {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return map_codex_error_to_response(&err);}attempt += 1;@@ -347,7 +464,12 @@ async fn live_stream_response(continue;}Err(err) => {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return map_codex_error_to_response(&err);}};@@ -359,6 +481,7 @@ async fn live_stream_response(ctx.clone(),turn_id,request_body.clone(),+ compact_boundary,).await{@@ -370,12 +493,22 @@ async fn live_stream_response(continue;}if attempt >= MAX_RETRYABLE_LIVE_STREAM_RETRIES {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return map_codex_error_to_response(&error);}let delay = compute_backoff_delay(attempt, error.retry_after.as_deref());if delay.exceeds_budget {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return map_codex_error_to_response(&error);}attempt += 1;@@ -392,6 +525,7 @@ async fn live_stream_response_once(ctx: RequestContext,turn_id: Option<u64>,request_body: translate::request::ResponsesRequest,+ compact_boundary: bool,) -> LiveStreamStart {let mut translator = LiveStreamTranslator::new(message_id, model.to_string());let mut upstream_sse_body = Vec::new();@@ -404,7 +538,12 @@ async fn live_stream_response_once(if retryable_live_start_codex_error(&err) {return LiveStreamStart::Retry { error: err };}- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return LiveStreamStart::Response(map_codex_error_to_response(&err));}};@@ -452,7 +591,12 @@ async fn live_stream_response_once(},};}- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return LiveStreamStart::Response(map_codex_failure_to_response(&message));}};@@ -464,6 +608,7 @@ async fn live_stream_response_once(turn_id,&request_body,&upstream_sse_body,+ compact_boundary,);return LiveStreamStart::Response(single_live_stream_response(chunk));}@@ -475,6 +620,7 @@ async fn live_stream_response_once(turn_id,request_body,upstream_sse_body,+ compact_boundary,));}if terminal {@@ -483,6 +629,7 @@ async fn live_stream_response_once(turn_id,&request_body,&upstream_sse_body,+ compact_boundary,);return LiveStreamStart::Response(empty_live_stream_response());}@@ -547,11 +694,17 @@ fn remaining_live_stream_response(turn_id: Option<u64>,request_body: translate::request::ResponsesRequest,mut upstream_sse_body: Vec<u8>,+ compact_boundary: bool,) -> Response {let (tx, rx) = tokio::sync::mpsc::channel::<Result<Bytes, std::io::Error>>(64);tokio::spawn(async move {if tx.send(Ok(Bytes::from(first_chunk))).await.is_err() {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return;}while let Some(item) = upstream_events.recv().await {@@ -562,7 +715,12 @@ fn remaining_live_stream_response(match translate_live_stream_payload(&mut translator, &payload, &ctx) {Ok(result) => result,Err(message) => {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );let chunk = translator.error_chunk(&message,"api_error",@@ -578,7 +736,12 @@ fn remaining_live_stream_response(if !chunk.is_empty() {record_live_stream_progress(&ctx, &chunk);if tx.send(Ok(Bytes::from(chunk))).await.is_err() {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );return;}}@@ -588,12 +751,18 @@ fn remaining_live_stream_response(turn_id,&request_body,&upstream_sse_body,+ compact_boundary,);return;}}Err(err) => {- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );let chunk =translator.finish_after_closed_completed_tool_call(ctx.traffic.as_deref());if !chunk.is_empty() {@@ -616,7 +785,12 @@ fn remaining_live_stream_response(}}- abort_continuation(ctx.session_id.as_deref(), turn_id);+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );let chunk = translator.finish_after_closed_completed_tool_call(ctx.traffic.as_deref());if !chunk.is_empty() {record_live_stream_progress(&ctx, &chunk);@@ -745,9 +919,13 @@ fn update_continuation_from_upstream(turn_id: Option<u64>,request_body: &translate::request::ResponsesRequest,upstream_body: &[u8],+ compact_boundary: bool,) {match finish_metadata_from_upstream(upstream_body) {Ok(Some(finish)) if finish.continuation_eligible => {+ if compact_boundary {+ activate_compaction(session_id, &request_body.model, &finish.output_items);+ }record_continuation(session_id,turn_id,@@ -756,7 +934,10 @@ fn update_continuation_from_upstream(&finish.output_items,);}- _ => abort_continuation(session_id, turn_id),+ _ => {+ abort_compaction_attempt(session_id, compact_boundary, request_body);+ abort_continuation(session_id, turn_id);+ }}}diff --git a/src/providers/codex/request_summary.rs b/src/providers/codex/request_summary.rsindex 777afcf..d987a9d 100644--- a/src/providers/codex/request_summary.rs+++ b/src/providers/codex/request_summary.rs@@ -101,6 +101,8 @@ pub fn summarize_codex_request_size(body: &ResponsesRequest) -> CodexRequestSizeResponsesInputItem::FunctionCall { .. } => Some("function_call".to_string()),ResponsesInputItem::FunctionCallOutput { .. } => Some("function_call_output".to_string()),ResponsesInputItem::Reasoning { .. } => Some("reasoning".to_string()),+ ResponsesInputItem::Compaction { .. } => Some("compaction".to_string()),+ ResponsesInputItem::CompactionTrigger => Some("compaction_trigger".to_string()),});let role_counts = count_items_by(&body.input, |item| match item {@@ -127,6 +129,10 @@ pub fn summarize_codex_request_size(body: &ResponsesRequest) -> CodexRequestSize("function_call_output".to_string(), None)}ResponsesInputItem::Reasoning { .. } => ("reasoning".to_string(), None),+ ResponsesInputItem::Compaction { .. } => ("compaction".to_string(), None),+ ResponsesInputItem::CompactionTrigger => {+ ("compaction_trigger".to_string(), None)+ }};let json_bytes_val =json_bytes(Some(&serde_json::to_value(item).unwrap_or_default()));diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rsindex e319ebb..ec81894 100644--- a/src/providers/codex/translate/request.rs+++ b/src/providers/codex/translate/request.rs@@ -160,6 +160,10 @@ pub enum ResponsesInputItem {summary: Vec<Value>,encrypted_content: String,},+ #[serde(rename = "compaction")]+ Compaction { encrypted_content: String },+ #[serde(rename = "compaction_trigger")]+ CompactionTrigger,}#[derive(Debug, Clone, Serialize, Deserialize)]@@ -301,15 +305,41 @@ fn reasoning_summary_requested(summary: Option<&str>) -> bool {// 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";+const COMPACT_MESSAGE_PREFIX: &str = "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.";+const COMPACT_MESSAGE_TASK: &str =+ "Your task is to create a detailed summary of the conversation so far";-fn is_compact_request(instructions: Option<&str>) -> bool {+pub(crate) fn is_compact_request(instructions: Option<&str>) -> bool {instructions.is_some_and(|text| text.contains(COMPACT_SYSTEM_MARKER))}+pub(crate) fn is_compact_message_text(text: &str) -> bool {+ text.contains(COMPACT_MESSAGE_PREFIX) && text.contains(COMPACT_MESSAGE_TASK)+}++fn is_compact_message_content(content: &Value) -> bool {+ match content {+ Value::String(text) => is_compact_message_text(text),+ Value::Array(blocks) => blocks.iter().any(|block| {+ block.get("type").and_then(Value::as_str) == Some("text")+ && block+ .get("text")+ .and_then(Value::as_str)+ .is_some_and(is_compact_message_text)+ }),+ _ => false,+ }+}++pub(crate) fn is_compact_messages_request(request: &MessagesRequest) -> bool {+ is_compact_request(flatten_system_text(request.extra.get("system")).as_deref())+ || request.messages.last().is_some_and(|message| {+ message.role == "user" && is_compact_message_content(&message.content)+ })+}+/// 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@@ -393,7 +423,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 is_compact = is_compact_messages_request(req);let input = build_input(req);let tools = read_tools(req)?;let tool_choice = map_tool_choice(req)?;@@ -1433,6 +1463,74 @@ mod tests {assert!(!is_compact_request(None));}+ #[test]+ fn compact_request_detected_from_final_user_message() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.6-sol",+ "messages": [+ {"role": "user", "content": "prior turn"},+ {+ "role": "user",+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": "tool-1",+ "content": "result"+ },+ {+ "type": "text",+ "text": concat!(+ "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.\n\n",+ "Your task is to create a detailed summary of the conversation so far, ",+ "paying close attention to the user's explicit requests."+ )+ }+ ]+ }+ ],+ "system": "You are Claude Code."+ }))+ .unwrap();++ assert!(is_compact_messages_request(&req));+ }++ #[test]+ fn compact_message_markers_must_be_in_final_user_message() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.6-sol",+ "messages": [+ {+ "role": "user",+ "content": concat!(+ "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.\n",+ "Your task is to create a detailed summary of the conversation so far."+ )+ },+ {"role": "user", "content": "continue normally"}+ ],+ "system": "You are Claude Code."+ }))+ .unwrap();++ assert!(!is_compact_messages_request(&req));+ }++ #[test]+ fn compact_message_requires_both_markers() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.6-sol",+ "messages": [{+ "role": "user",+ "content": "Your task is to create a detailed summary of the conversation so far."+ }],+ "system": "You are Claude Code."+ }))+ .unwrap();++ assert!(!is_compact_messages_request(&req));+ }+#[test]fn compact_effort_cap_parses_env_values() {assert!(matches!(compact_effort_cap_from(None), Some(Effort::Low)));diff --git a/src/server.rs b/src/server.rsindex c7f59f9..fe259f6 100644--- a/src/server.rs+++ b/src/server.rs@@ -411,6 +411,13 @@ async fn dispatch_request(}};+ if !count_tokens+ && provider.name() != "codex"+ && let Some(session_id) = session_id.as_deref()+ {+ crate::providers::codex::clear_session_compaction(session_id);+ }+let effort = crate::providers::translate_shared::read_effort(&body).ok().flatten()diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex ea54456..fcd8ff6 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -4,6 +4,7 @@use axum::body::Body;use axum::http::{Method, Request, StatusCode};use axum::response::Response;+use claude_code_proxy::providers::codex::compaction::clear_all_compactions_for_tests;use claude_code_proxy::providers::codex::continuation::clear_all_continuations_for_tests;use claude_code_proxy::providers::codex::websocket::clear_codex_websocket_pool_for_tests;use claude_code_proxy::{registry::Registry, server::app};@@ -624,6 +625,7 @@ async fn smoke_kimi_messages_uses_mock_upstream() {let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());let _base_url_env = EnvGuard::set("CCP_KIMI_BASE_URL", &upstream);+ let _compaction_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "1");let response = call_messages("kimi-for-coding").await;assert_eq!(response.status(), StatusCode::OK);@@ -638,6 +640,8 @@ async fn smoke_kimi_messages_uses_mock_upstream() {let sent = captured.lock().unwrap().clone().unwrap();assert_eq!(sent["model"], "kimi-for-coding");assert_eq!(sent["stream"], true);+ assert!(sent.get("input").is_none());+ assert!(!sent.to_string().contains("compaction_trigger"));}// ---------------------------------------------------------------------------@@ -688,6 +692,182 @@ async fn smoke_codex_http_messages_uses_mock_upstream() {assert_eq!(sent["stream"], true);}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_server_compaction_replays_native_history() {+ let _guard = env_lock();+ clear_all_compactions_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let captured = Arc::new(Mutex::new(Vec::new()));+ let upstream = spawn_http_upstream({+ let captured = captured.clone();+ move |body: Value| {+ let is_compaction = body["input"].as_array().is_some_and(|input| {+ input.last().and_then(|item| item["type"].as_str())+ == Some("compaction_trigger")+ });+ let request_number = {+ let mut requests = captured.lock().unwrap();+ requests.push(body);+ requests.len()+ };+ if is_compaction {+ concat!(+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"compaction\",\"encrypted_content\":\"opaque-history\"}}\n\n",+ "data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_compact\",\"usage\":{\"input_tokens\":100,\"output_tokens\":1}}}\n\n"+ )+ .as_bytes()+ .to_vec()+ } else {+ let text = if request_number == 2 {+ "portable summary with enough detail to anchor the compacted conversation"+ } else {+ "compacted ok"+ };+ format!(+ "data: {{\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{{\"type\":\"message\",\"id\":\"msg_up\"}}}}\n\n\+ data: {{\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"{text}\"}}\n\n\+ data: {{\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{{\"type\":\"message\"}}}}\n\n\+ data: {{\"type\":\"response.completed\",\"response\":{{\"id\":\"resp_{request_number}\",\"usage\":{{\"input_tokens\":5,\"output_tokens\":2}}}}}}\n\n"+ )+ .into_bytes()+ }+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let _compaction_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "1");+ let compact_response = call_messages_body(json!({+ "model": "gpt-5.6-sol",+ "max_tokens": 64,+ "system": "You are Claude Code.",+ "messages": [+ {"role":"user","content":"old conversation"},+ {"role":"assistant","content":[{"type":"tool_use","id":"tool-1","name":"Read","input":{}}]},+ {"role":"user","content":[+ {"type":"tool_result","tool_use_id":"tool-1","content":"result"},+ {"type":"text","text":"CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.\n\nYour task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests."}+ ]}+ ]+ }))+ .await;+ assert_eq!(compact_response.status(), StatusCode::OK);++ let response = call_messages_body(json!({+ "model": "gpt-5.6-sol",+ "max_tokens": 64,+ "system": "current instructions",+ "messages": [+ {"role":"user","content":"<summary>portable summary with enough detail to anchor the compacted conversation</summary>"},+ {"role":"user","content":"continue"}+ ]+ }))+ .await;+ assert_eq!(response.status(), StatusCode::OK);+ let value: Value = serde_json::from_slice(+ &axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap(),+ )+ .unwrap();+ assert_eq!(value["content"][0]["text"], "compacted ok");++ let requests = captured.lock().unwrap();+ assert_eq!(requests.len(), 3);+ assert_eq!(requests[0]["model"], "gpt-5.6-sol");+ assert!(requests[0].get("client_metadata").is_some());+ assert_eq!(+ requests[0]["input"].as_array().unwrap().last().unwrap()["type"],+ "compaction_trigger"+ );+ assert!(+ !requests[0]+ .to_string()+ .contains("Your task is to create a detailed summary")+ );+ assert!(+ requests[1]+ .to_string()+ .contains("Your task is to create a detailed summary")+ );+ assert!(!requests[1].to_string().contains("opaque-history"));+ let replay = requests[2]["input"].as_array().unwrap();+ assert!(requests[2].get("client_metadata").is_some());+ assert!(requests[2].to_string().contains("current instructions"));+ let compaction = replay+ .iter()+ .find(|item| item["type"] == "compaction")+ .unwrap();+ assert_eq!(compaction["encrypted_content"], "opaque-history");+ assert!(replay.iter().any(|item| item["role"] == "user"));+ clear_all_compactions_for_tests();+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_compaction_failure_preserves_portable_summary() {+ let _guard = env_lock();+ clear_all_compactions_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let captured = Arc::new(Mutex::new(Vec::new()));+ let upstream = spawn_http_upstream({+ let captured = captured.clone();+ move |body: Value| {+ let is_compaction = body["input"].as_array().is_some_and(|input| {+ input.last().and_then(|item| item["type"].as_str())+ == Some("compaction_trigger")+ });+ captured.lock().unwrap().push(body);+ if is_compaction {+ b"data: {\"type\":\"response.completed\",\"response\":{}}\n\n".to_vec()+ } else {+ concat!(+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"portable fallback\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",+ "data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n"+ )+ .as_bytes()+ .to_vec()+ }+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let _compaction_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "1");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "system": "You are a helpful AI assistant tasked with summarizing conversations.",+ "messages": [{"role":"user","content":"old conversation"}]+ }))+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ let value: Value = serde_json::from_slice(+ &axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap(),+ )+ .unwrap();+ assert_eq!(value["content"][0]["text"], "portable fallback");++ let requests = captured.lock().unwrap();+ assert_eq!(requests.len(), 2);+ assert!(requests[1].to_string().contains("old conversation"));+ assert!(!requests[1].to_string().contains("opaque-history"));+}+#[allow(clippy::await_holding_lock)]#[tokio::test]async fn smoke_codex_http_context_window_error_requests_compaction() {