Skip to content

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.md
index 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 more
diff --git a/README.md b/README.md
index 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 while
keeping `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 native
Responses `web_search` tool with live external web access and non-empty native
domain 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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 continuation
let 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.rs
index 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) -> CodexRequestSize
ResponsesInputItem::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.rs
index 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.rs
index 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.rs
index 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() {