From 359559abc3f60f20ab8aed0931e996d4cbac05fc Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Mon, 7 Sep 2026 11:36:48 +0200
Subject: [PATCH 01/10] feat(compact): reconcile openai_responses_compact with
 main (#30)

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/config.rs   |  13 +
 apis/src/openai/responses/compact/mod.rs      | 541 +++++++++++++++---
 apis/src/openai/responses/compact/tests.rs    | 327 +++++++++--
 .../responses/openai_responses_proxy/mod.rs   |   6 +-
 apis/src/openai/responses/store/filter.rs     |  17 +-
 .../src/openai/responses/store/input_items.rs |   8 +-
 apis/src/openai/responses/store/tests.rs      |  35 ++
 .../openai/translation/chat_completions.rs    |   6 +-
 docs/filters/openai_responses_compact.md      |  10 +-
 .../tests/suite/examples/compact.rs           | 125 +++-
 10 files changed, 944 insertions(+), 144 deletions(-)

diff --git a/apis/src/openai/responses/compact/config.rs b/apis/src/openai/responses/compact/config.rs
index 227962f1f4..9c915d44ac 100644
--- a/apis/src/openai/responses/compact/config.rs
+++ b/apis/src/openai/responses/compact/config.rs
@@ -52,6 +52,12 @@ pub(super) struct CompactFilterConfig {
     #[serde(default = "default_tiktoken_encoding")]
     pub tiktoken_encoding: String,
 
+    /// Prefix prepended to the summary when translating compaction
+    /// items to backend messages. Defaults to
+    /// `"[Previous conversation summary]\n\n"`.
+    #[serde(default)]
+    pub summary_prefix: Option<String>,
+
     /// Callout timeout in milliseconds.
     #[serde(default)]
     pub timeout_ms: Option<u64>,
@@ -94,6 +100,9 @@ pub(super) struct ValidatedConfig {
     /// Tiktoken encoding name.
     pub tiktoken_encoding: String,
 
+    /// Prefix prepended to the summary in backend messages.
+    pub summary_prefix: String,
+
     /// Shared callout settings (timeout, failure mode, status).
     pub callout: CalloutSettings,
 }
@@ -143,6 +152,10 @@ pub(super) fn build_config(raw: &CompactFilterConfig) -> Result<ValidatedConfig,
         address_policy,
         default_model: raw.default_model.clone(),
         tiktoken_encoding: raw.tiktoken_encoding.clone(),
+        summary_prefix: raw
+            .summary_prefix
+            .clone()
+            .unwrap_or_else(|| crate::openai::responses::compact::DEFAULT_SUMMARY_PREFIX.to_owned()),
         callout: CalloutSettings {
             timeout_ms,
             on_failure: raw.on_failure.unwrap_or(OnFailure::Closed),
diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index ec08164761..1b0e94e15b 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -53,6 +53,7 @@ use self::config::{CompactFilterConfig, ValidatedConfig, build_config};
 use super::{error::responses_error_rejection, state::ResponsesState};
 use crate::{
     callout_policy::OnFailure,
+    store::{ResponseRecord, ResponseStoreRegistry},
     subrequest::{self, SubRequest, SubRequestClient},
 };
 
@@ -74,6 +75,10 @@ user preferences, and important context. The summary \
 will replace the full conversation history, so it must \
 capture everything needed to continue coherently.";
 
+/// Default prefix prepended to the summary when translating
+/// compaction items to backend-compatible messages.
+pub const DEFAULT_SUMMARY_PREFIX: &str = "[Previous conversation summary]\n\n";
+
 // -----------------------------------------------------------------------------
 // CompactionParams
 // -----------------------------------------------------------------------------
@@ -98,9 +103,17 @@ struct CompactionParams {
 /// of at least 1000. Invalid or missing `compact_threshold` values
 /// produce an `invalid_request_error`.
 ///
-/// Compaction only applies to multi-turn requests where
-/// `openai_responses_rehydrate` has loaded stored conversation
-/// history. Single-turn requests are released without compaction.
+/// Compaction applies in two scenarios:
+///
+/// - **Rehydrated history** — stored history loaded via `previous_response_id` or `conversation`. Only the stored
+///   history is summarized; the current turn is preserved.
+///
+/// - **Explicit compact** — `POST /v1/responses/compact` with a `response_id`. Loads stored messages, summarizes them,
+///   and persists a new compacted response.
+///
+/// Direct input requests (full conversation in `input` with no stored history) skip reactive compaction because
+/// `state.input == state.messages` — there is no separable "current turn" to preserve after summarization.
+/// Requests without rehydrated history are released without compaction.
 ///
 /// Praxis runs `StreamBuffer` body hooks before header-phase request
 /// filters. This filter therefore requires
@@ -126,6 +139,7 @@ struct CompactionParams {
 /// allow_private_inference_url: true
 /// default_model: gpt-4o-mini
 /// tiktoken_encoding: cl100k_base
+/// summary_prefix: "[Previous conversation summary]\n\n"
 /// timeout_ms: 30000
 /// on_failure: closed
 /// status_on_error: 502
@@ -223,6 +237,38 @@ impl CompactFilter {
         }
     }
 
+    /// Run a summarization callout for an explicit compact request.
+    async fn summarize_messages(
+        &self,
+        req: &ExplicitCompactRequest,
+        messages: &[Value],
+    ) -> Result<String, FilterAction> {
+        let conversation_text = build_conversation_text(messages);
+        let model = req.model.as_deref().unwrap_or(&self.config.default_model);
+        let instructions = req.instructions.as_deref();
+        let request = build_summarization_request(&conversation_text, instructions, model);
+        let timeout = Duration::from_millis(self.config.callout.timeout_ms);
+        let result = subrequest::execute_url(
+            &self.client,
+            &self.config.inference_url,
+            request,
+            MAX_SUMMARIZATION_RESPONSE_BYTES,
+            timeout,
+            self.config.address_policy,
+        )
+        .await;
+        match self.handle_subrequest_result(result, false) {
+            Ok(Some(s)) => Ok(s),
+            Ok(None) => Err(FilterAction::Reject(responses_error_rejection(
+                502,
+                "server_error",
+                "compaction callout failed",
+                false,
+            ))),
+            Err(action) => Err(action),
+        }
+    }
+
     /// Apply the configured open/closed policy on a callout error.
     fn on_callout_error(&self, message: &str, streaming: bool) -> Result<Option<String>, FilterAction> {
         match self.config.callout.on_failure {
@@ -235,6 +281,103 @@ impl CompactFilter {
             ))),
         }
     }
+
+    /// Apply compaction results: replace messages and persist the
+    /// compaction response to the store.
+    async fn apply_compaction(&self, ctx: &mut HttpFilterContext<'_>, summary: &str, model: &str) {
+        let compaction_id = format!("compact_{}", ctx.id_generator.generate(ctx.time_source));
+        let resp_id = format!("resp_{}", ctx.id_generator.generate(ctx.time_source));
+        let created_at = i64::try_from(ctx.time_source.now().as_secs()).unwrap_or(i64::MAX);
+        let store = ctx
+            .extensions
+            .get::<ResponseStoreRegistry>()
+            .and_then(|r| r.get("default"));
+        let tenant_id = ctx.get_metadata("responses.tenant_id").unwrap_or("default").to_owned();
+
+        // Mutate state and take an owned snapshot of the compacted messages,
+        // releasing the `&mut ResponsesState` borrow before the store await.
+        let persisted_messages = {
+            let Some(state) = ctx.extensions.get_mut::<ResponsesState>() else {
+                warn!("ResponsesState missing in apply_compaction");
+                return;
+            };
+            replace_messages(
+                state,
+                build_compaction_item(&compaction_id, summary, &self.config.summary_prefix),
+            );
+            state.persisted_messages.clone()
+        };
+        if let Some(store) = store.as_deref() {
+            persist_compaction_response(store, &resp_id, model, &tenant_id, created_at, persisted_messages).await;
+        }
+    }
+
+    /// Check threshold and run summarization if exceeded.
+    ///
+    /// Returns `Ok(Some((summary, model)))` when compaction ran,
+    /// `Ok(None)` when skipped, or `Err(FilterAction)` to
+    /// short-circuit.
+    async fn check_and_summarize(
+        &self,
+        state: &ResponsesState,
+        streaming: bool,
+    ) -> Result<Option<(String, String)>, FilterAction> {
+        let (params, conversation_text) = match should_compact(state, &self.config.tiktoken_encoding) {
+            Ok(Some(pair)) => pair,
+            Ok(None) => return Ok(None),
+            Err(msg) => {
+                let rej = responses_error_rejection(400, "invalid_request_error", &msg, streaming);
+                return Err(FilterAction::Reject(rej));
+            },
+        };
+        let summary = match self
+            .execute_compaction(state, &params, streaming, &conversation_text)
+            .await
+        {
+            Ok(Some(s)) => s,
+            Ok(None) => return Ok(None),
+            Err(action) => return Err(action),
+        };
+        let model = params
+            .compaction_model
+            .unwrap_or_else(|| self.config.default_model.clone());
+        Ok(Some((summary, model)))
+    }
+
+    /// Handle an explicit `POST /v1/responses/compact` request.
+    ///
+    /// Loads a stored conversation by `response_id`, compacts it via
+    /// a summarization callout, stores the compacted result, and
+    /// returns the new response.
+    async fn handle_explicit_compact(
+        &self,
+        ctx: &HttpFilterContext<'_>,
+        body: &Option<Bytes>,
+    ) -> Result<FilterAction, FilterError> {
+        match self.do_explicit_compact(ctx, body).await {
+            Ok(action) | Err(action) => Ok(action),
+        }
+    }
+
+    /// Inner logic for explicit compact, using `FilterAction` as the error type.
+    async fn do_explicit_compact(
+        &self,
+        ctx: &HttpFilterContext<'_>,
+        body: &Option<Bytes>,
+    ) -> Result<FilterAction, FilterAction> {
+        let req = parse_compact_request_body(body)?;
+        let (store, tenant_id) = resolve_store_and_tenant(ctx)?;
+        let record = fetch_response(&*store, &tenant_id, &req).await?;
+        let messages = extract_stored_messages(record)?;
+        let summary = self.summarize_messages(&req, &messages).await?;
+        let response_object = build_and_persist_compaction(self, ctx, &*store, &tenant_id, &req, &summary).await?;
+        let body_bytes = serde_json::to_vec(&response_object).unwrap_or_default();
+        Ok(FilterAction::Reject(
+            praxis_filter::Rejection::status(200)
+                .with_header("content-type", "application/json")
+                .with_body(Bytes::from(body_bytes)),
+        ))
+    }
 }
 
 #[async_trait]
@@ -257,48 +400,35 @@ impl HttpFilter for CompactFilter {
         Ok(FilterAction::Continue)
     }
 
-    #[expect(
-        clippy::too_many_lines,
-        reason = "filter request body handling is inherently sequential"
-    )]
     async fn on_request_body(
         &self,
         ctx: &mut HttpFilterContext<'_>,
-        _body: &mut Option<Bytes>,
+        body: &mut Option<Bytes>,
         end_of_stream: bool,
     ) -> Result<FilterAction, FilterError> {
         if !end_of_stream {
             return Ok(FilterAction::Continue);
         }
+        if is_explicit_compact_request(ctx) {
+            return self.handle_explicit_compact(ctx, body).await;
+        }
         if !is_responses_request(ctx) {
             return Ok(FilterAction::Release);
         }
         let streaming = is_streaming(ctx);
+        if !ensure_compactable_state(ctx) {
+            return Ok(FilterAction::Release);
+        }
         let Some(state) = ctx.extensions.get::<ResponsesState>() else {
+            warn!("ResponsesState missing after ensure_compactable_state");
             return Ok(FilterAction::Release);
         };
-        let (params, conversation_text) = match should_compact(state, &self.config.tiktoken_encoding) {
-            Ok(Some(pair)) => pair,
-            Ok(None) => return Ok(FilterAction::Release),
-            Err(msg) => {
-                let rej = responses_error_rejection(400, "invalid_request_error", &msg, streaming);
-                return Ok(FilterAction::Reject(rej));
-            },
-        };
-        if !state.history_rehydrated {
-            return Ok(FilterAction::Release);
-        }
-        let compaction = self.execute_compaction(state, &params, streaming, &conversation_text);
-        let summary = match compaction.await {
-            Ok(Some(s)) => s,
+        let (summary, model) = match self.check_and_summarize(state, streaming).await {
+            Ok(Some(result)) => result,
             Ok(None) | Err(FilterAction::Release) => return Ok(FilterAction::Release),
             Err(action) => return Ok(action),
         };
-        let Some(state) = ctx.extensions.get_mut::<ResponsesState>() else {
-            return Ok(FilterAction::Release);
-        };
-        let compaction_id = format!("compact_{}", ctx.id_generator.generate(ctx.time_source));
-        replace_messages(state, build_compaction_item(&compaction_id, &summary));
+        self.apply_compaction(ctx, &summary, &model).await;
         ctx.set_metadata("responses.compacted", "true");
         Ok(FilterAction::Release)
     }
@@ -308,15 +438,46 @@ impl HttpFilter for CompactFilter {
 // Compaction Logic
 // -----------------------------------------------------------------------------
 
+/// Returns `true` when compaction should proceed.
+fn ensure_compactable_state(ctx: &HttpFilterContext<'_>) -> bool {
+    is_compactable(ctx.extensions.get::<ResponsesState>())
+}
+
+/// Check whether the given state qualifies for reactive compaction.
+///
+/// Returns `true` only when rehydrated history is present. Direct
+/// input requests (no `previous_response_id`) are skipped because
+/// `state.input == state.messages` — there is no separable "current
+/// turn" to preserve after summarization. Use the explicit
+/// `POST /v1/responses/compact` endpoint for non-rehydrated history.
+///
+/// This gate is the single decision point for direct-input handling:
+/// `should_compact` and `replace_messages` retain direct-input branches
+/// (and unit tests for them) documenting the lower-level contract, but
+/// those branches are unreachable through the filter while this returns
+/// `false` for non-rehydrated state.
+fn is_compactable(state: Option<&ResponsesState>) -> bool {
+    let Some(state) = state else {
+        return false;
+    };
+    state.history_rehydrated
+}
+
 /// Check whether compaction should run and return the params + text.
 ///
 /// Returns `None` if there is no compaction config, the encoding is
 /// unknown, or the token count is below the threshold.
 ///
-/// The token estimate includes instructions and tool definitions in
+/// When `previous_usage` is available from the rehydrated response,
+/// its `total_tokens` is used directly — avoiding the cost of BPE
+/// tokenization. Falls back to tiktoken estimation otherwise. The
+/// fallback estimate includes instructions and tool definitions in
 /// addition to conversation messages, since all three contribute to
 /// the rendered context sent to the model.
-#[expect(clippy::too_many_lines, reason = "token threshold estimation is sequential")]
+///
+/// The check is reactive: the token count reflects the *previous*
+/// turn's usage, not the current one. If the previous turn exceeded
+/// the threshold, we compact before sending this turn.
 fn should_compact(
     state: &ResponsesState,
     tiktoken_encoding: &str,
@@ -324,54 +485,65 @@ fn should_compact(
     let Some(params) = extract_compaction_config(&state.context_management)? else {
         return Ok(None);
     };
-
-    let conversation_text = build_conversation_text(&state.messages);
-    let Some(message_tokens) = get_token_count(&conversation_text, tiktoken_encoding) else {
-        return Ok(None);
+    let history = if state.history_rehydrated {
+        let end = state.messages.len().saturating_sub(state.input.len());
+        state.messages.get(..end).unwrap_or(&state.messages)
+    } else {
+        &state.messages
     };
 
-    let overhead_text = build_context_overhead_text(state);
-    let overhead_tokens = if overhead_text.is_empty() {
-        0
-    } else {
-        get_token_count(&overhead_text, tiktoken_encoding).unwrap_or(0)
+    if let Some(token_count) = previous_usage_total(state) {
+        if !exceeds_threshold(token_count, &params) {
+            return Ok(None);
+        }
+        return Ok(Some((params, build_conversation_text(history))));
+    }
+
+    debug!("previous_usage unavailable, falling back to tiktoken estimation");
+    let conversation_text = build_conversation_text(history);
+    let overhead = build_context_overhead_text(&state.request_body);
+    let full_text = format!("{conversation_text}\n\n{overhead}");
+    let Some(token_count) = get_token_count(&full_text, tiktoken_encoding) else {
+        return Ok(None);
     };
+    if !exceeds_threshold(token_count, &params) {
+        return Ok(None);
+    }
+    Ok(Some((params, conversation_text)))
+}
 
-    let token_count = message_tokens + overhead_tokens;
+/// Log and return whether `token_count` exceeds the compaction threshold.
+fn exceeds_threshold(token_count: u64, params: &CompactionParams) -> bool {
     if token_count <= params.compact_threshold {
         debug!(
             token_count,
-            message_tokens,
-            overhead_tokens,
             threshold = params.compact_threshold,
             "under threshold, skipping"
         );
-        return Ok(None);
+        return false;
     }
     debug!(
         token_count,
-        message_tokens,
-        overhead_tokens,
         threshold = params.compact_threshold,
         "threshold exceeded, compacting"
     );
-    Ok(Some((params, conversation_text)))
+    true
 }
 
-/// Build the text for instructions and tool definitions that live
-/// outside the message list but still consume context window tokens.
-fn build_context_overhead_text(state: &ResponsesState) -> String {
-    let mut buf = String::new();
-    if let Some(instructions) = state.request_body.get("instructions").and_then(Value::as_str) {
-        buf.push_str(instructions);
-    }
-    for tool in &state.tools {
-        if !buf.is_empty() {
-            buf.push('\n');
-        }
-        buf.push_str(&tool.to_string());
-    }
-    buf
+/// Extract `total_tokens` from the previous response's usage object.
+fn previous_usage_total(state: &ResponsesState) -> Option<u64> {
+    let total = state.previous_usage.as_ref()?.get("total_tokens")?.as_u64()?;
+    debug!(
+        count = total,
+        source = "previous_usage",
+        "token count from prior response"
+    );
+    Some(total)
+}
+
+/// Check whether this is an explicit `POST /v1/responses/compact` request.
+pub(super) fn is_explicit_compact_request(ctx: &HttpFilterContext<'_>) -> bool {
+    ctx.request.method == http::Method::POST && ctx.request.uri.path().trim_end_matches('/') == "/v1/responses/compact"
 }
 
 /// Check whether this is an OpenAI Responses API request.
@@ -385,6 +557,138 @@ fn is_streaming(ctx: &HttpFilterContext<'_>) -> bool {
         .is_some_and(|v| v == "true")
 }
 
+// -----------------------------------------------------------------------------
+// Explicit Compact Endpoint Helpers
+// -----------------------------------------------------------------------------
+
+/// Parsed body for `POST /v1/responses/compact`.
+struct ExplicitCompactRequest {
+    /// The stored response to compact.
+    response_id: String,
+    /// Optional model override for the summarization call.
+    model: Option<String>,
+    /// Optional instructions to prepend to the summarization prompt.
+    instructions: Option<String>,
+}
+
+/// Parse and validate the `POST /v1/responses/compact` body.
+fn parse_compact_request_body(body: &Option<Bytes>) -> Result<ExplicitCompactRequest, FilterAction> {
+    let bytes = body
+        .as_ref()
+        .filter(|b| !b.is_empty())
+        .ok_or_else(|| reject_compact(400, "invalid_request_error", "request body is empty"))?;
+    let parsed: Value = serde_json::from_slice(bytes).map_err(|e| {
+        debug!(error = %e, "compact request body parse failed");
+        reject_compact(400, "invalid_request_error", "invalid JSON body")
+    })?;
+    let response_id = parsed
+        .get("response_id")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .ok_or_else(|| reject_compact(400, "invalid_request_error", "missing required field: response_id"))?
+        .to_owned();
+    Ok(ExplicitCompactRequest {
+        response_id,
+        model: parsed.get("model").and_then(Value::as_str).map(ToOwned::to_owned),
+        instructions: parsed
+            .get("instructions")
+            .and_then(Value::as_str)
+            .map(ToOwned::to_owned),
+    })
+}
+
+/// Look up the store and tenant from the request context.
+fn resolve_store_and_tenant(
+    ctx: &HttpFilterContext<'_>,
+) -> Result<(std::sync::Arc<dyn crate::store::ResponseStore>, String), FilterAction> {
+    let store = ctx
+        .extensions
+        .get::<ResponseStoreRegistry>()
+        .and_then(|r| r.get("default"))
+        .ok_or_else(|| reject_compact(500, "server_error", "response store not available"))?;
+    let tenant_id = ctx.get_metadata("responses.tenant_id").unwrap_or("default").to_owned();
+    Ok((store, tenant_id))
+}
+
+/// Fetch a stored response.
+async fn fetch_response(
+    store: &dyn crate::store::ResponseStore,
+    tenant_id: &str,
+    req: &ExplicitCompactRequest,
+) -> Result<ResponseRecord, FilterAction> {
+    match store.get_response(tenant_id, &req.response_id).await {
+        Ok(Some(r)) => Ok(r),
+        Ok(None) => Err(reject_compact(404, "not_found_error", "response not found")),
+        Err(e) => {
+            warn!(error = %e, "failed to fetch response for compact");
+            Err(reject_compact(500, "server_error", "failed to fetch response"))
+        },
+    }
+}
+
+/// Extract messages from a stored response.
+fn extract_stored_messages(record: ResponseRecord) -> Result<Vec<Value>, FilterAction> {
+    match record.messages {
+        Value::Array(arr) if !arr.is_empty() => Ok(arr),
+        _ => Err(reject_compact(
+            400,
+            "invalid_request_error",
+            "response has no messages to compact",
+        )),
+    }
+}
+
+/// Build and persist the compaction result for an explicit compact request.
+#[expect(
+    clippy::too_many_arguments,
+    clippy::too_many_lines,
+    reason = "all parameters are needed"
+)]
+async fn build_and_persist_compaction(
+    filter: &CompactFilter,
+    ctx: &HttpFilterContext<'_>,
+    store: &dyn crate::store::ResponseStore,
+    tenant_id: &str,
+    req: &ExplicitCompactRequest,
+    summary: &str,
+) -> Result<Value, FilterAction> {
+    let compaction_id = format!("compact_{}", ctx.id_generator.generate(ctx.time_source));
+    let resp_id = format!("resp_{}", ctx.id_generator.generate(ctx.time_source));
+    let created_at = i64::try_from(ctx.time_source.now().as_secs()).unwrap_or(i64::MAX);
+    let model = req.model.as_deref().unwrap_or(&filter.config.default_model);
+    let compaction_item = build_compaction_item(&compaction_id, summary, &filter.config.summary_prefix);
+    let compacted_messages = Value::Array(vec![compaction_item]);
+    let response_object = serde_json::json!({
+        "id": resp_id,
+        "object": "response",
+        "status": "completed",
+        "model": model,
+        "created_at": created_at,
+        "previous_response_id": req.response_id,
+        "output": compacted_messages,
+    });
+
+    let record = ResponseRecord {
+        id: resp_id,
+        tenant_id: tenant_id.to_owned(),
+        created_at,
+        model: model.to_owned(),
+        response_object: response_object.clone(),
+        input: compacted_messages.clone(),
+        messages: compacted_messages,
+    };
+    store.upsert_response(&record).await.map_err(|e| {
+        warn!(error = %e, "failed to persist explicit compaction response");
+        reject_compact(500, "server_error", "failed to persist compaction response")
+    })?;
+    Ok(response_object)
+}
+
+/// Build a `FilterAction::Reject` for an explicit compact error.
+fn reject_compact(status: u16, code: &str, message: &str) -> FilterAction {
+    FilterAction::Reject(responses_error_rejection(status, code, message, false))
+}
+
 /// Parse the `context_management` JSON to find a compaction config.
 ///
 /// The `context_management` field is an array like:
@@ -533,36 +837,107 @@ fn parse_summarization_response(body: &[u8]) -> Result<String, String> {
 /// Build the compaction output item.
 ///
 /// Returns: `{"type": "compaction", "id": "<id>", "encrypted_content": "<base64>"}`
+/// with an optional `"summary_prefix"` when it differs from the default.
 ///
 /// The summary is base64-encoded into `encrypted_content` to match the
 /// OpenAI Responses API compaction item shape and make the content opaque
 /// to clients.
-fn build_compaction_item(id: &str, summary: &str) -> Value {
+fn build_compaction_item(id: &str, summary: &str, summary_prefix: &str) -> Value {
     let encrypted_content = base64::engine::general_purpose::STANDARD.encode(summary);
-    serde_json::json!({
+    let mut item = serde_json::json!({
         "type": "compaction",
         "id": id,
         "encrypted_content": encrypted_content
-    })
+    });
+    if summary_prefix != DEFAULT_SUMMARY_PREFIX
+        && let Some(obj) = item.as_object_mut()
+    {
+        obj.insert("summary_prefix".to_owned(), Value::String(summary_prefix.to_owned()));
+    }
+    item
 }
 
 /// Replace conversation history with the compaction item.
 ///
-/// After replacement:
-/// - `state.messages` = `[compaction_item, ...state.input]`
-/// - `state.persisted_messages` = `[compaction_item, ...state.input]`
+/// In the **rehydrated** path `state.input` holds only the current
+/// turn's messages (rehydrate prepends history to `state.messages`
+/// but leaves `input` untouched). Result:
+/// `[compaction_item, ...current_turn_input]`.
 ///
-/// The compaction item is `{"type": "compaction", "encrypted_content": "<base64>"}`.
-/// `state.input` holds the current request's input items (unchanged
-/// by rehydrate), so the current turn's messages are preserved.
+/// In the **direct input** path `state.input == state.messages`
+/// (no rehydration). Preserving `input` would duplicate the entire
+/// conversation after the summary. Result: `[compaction_item]`.
 fn replace_messages(state: &mut ResponsesState, compaction_item: Value) {
-    let mut new_messages = Vec::with_capacity(state.input.len() + 1);
-    new_messages.push(compaction_item);
-    new_messages.extend(state.input.iter().cloned());
-    state.persisted_messages = new_messages.clone();
+    let direct_input = !state.history_rehydrated;
+    let new_messages = if direct_input {
+        vec![compaction_item]
+    } else {
+        let mut msgs = Vec::with_capacity(state.input.len() + 1);
+        msgs.push(compaction_item);
+        msgs.extend(state.input.iter().cloned());
+        msgs
+    };
+    state.persisted_messages.clone_from(&new_messages);
     state.messages = new_messages;
 }
 
+/// Persist a hidden compaction response to the store so that it can
+/// be referenced via `previous_response_id` in future requests.
+///
+/// Best-effort: a store failure is logged but does not block the
+/// request — the main response's store filter will still persist
+/// the compacted messages as part of the regular response record.
+#[expect(clippy::too_many_arguments, reason = "all fields are needed for the record")]
+async fn persist_compaction_response(
+    store: &dyn crate::store::ResponseStore,
+    response_id: &str,
+    model: &str,
+    tenant_id: &str,
+    created_at: i64,
+    persisted_messages: Vec<Value>,
+) {
+    let persisted = Value::Array(persisted_messages);
+    let record = ResponseRecord {
+        id: response_id.to_owned(),
+        tenant_id: tenant_id.to_owned(),
+        created_at,
+        model: model.to_owned(),
+        response_object: serde_json::json!({
+            "id": response_id,
+            "object": "response",
+            "status": "completed",
+            "model": model,
+            "created_at": created_at,
+        }),
+        input: persisted.clone(),
+        messages: persisted,
+    };
+    if let Err(e) = store.upsert_response(&record).await {
+        warn!(error = %e, id = %response_id, "failed to persist compaction response");
+    }
+}
+
+/// Build a text representation of instructions and tool definitions for token counting.
+///
+/// Returns an empty string when neither field is present. The result is
+/// concatenated with conversation text so tiktoken counts the full context
+/// window overhead, matching the behavior of `previous_usage.total_tokens`.
+fn build_context_overhead_text(request_body: &Value) -> String {
+    let mut buf = String::new();
+    if let Some(instructions) = request_body.get("instructions").and_then(Value::as_str)
+        && !instructions.is_empty()
+    {
+        append_line(&mut buf, "instructions", instructions);
+    }
+    if let Some(tools) = request_body.get("tools").and_then(Value::as_array)
+        && !tools.is_empty()
+    {
+        let serialized = serde_json::to_string(tools).unwrap_or_default();
+        append_line(&mut buf, "tools", &serialized);
+    }
+    buf
+}
+
 /// Format a message array as readable text for the summarization prompt.
 ///
 /// Each message becomes `<label>: <text>`, separated by blank lines.
@@ -610,8 +985,7 @@ fn append_line(buf: &mut String, label: &str, text: &str) {
     buf.push_str(text);
 }
 
-/// Decode a compaction item's `encrypted_content` field to a UTF-8 string.
-/// Append a compaction item's summary to the buffer without a String allocation.
+/// Append a compaction item's summary to the buffer.
 ///
 /// Decodes `encrypted_content` and borrows the result as `&str` directly,
 /// avoiding the `String::from_utf8` conversion that would copy the buffer.
@@ -641,7 +1015,6 @@ fn append_function_call(buf: &mut String, name: &str, args: &str) {
     buf.push(')');
 }
 
-
 /// Extract text content from a message's `content` field.
 ///
 /// Content can be a plain string, an array of content parts
@@ -657,11 +1030,19 @@ fn extract_content(msg: &Value) -> Cow<'_, str> {
         return Cow::Borrowed(s);
     }
     if let Some(arr) = content.as_array() {
-        let texts: Vec<&str> = arr
-            .iter()
-            .filter_map(|part| part.get("text").and_then(Value::as_str))
-            .collect();
-        return Cow::Owned(texts.join(" "));
+        let mut joined = String::new();
+        for part in arr {
+            if let Some(text) = part.get("text").and_then(Value::as_str) {
+                if !joined.is_empty() {
+                    joined.push(' ');
+                }
+                joined.push_str(text);
+            }
+        }
+        if !joined.is_empty() {
+            return Cow::Owned(joined);
+        }
+        return Cow::Borrowed("");
     }
     Cow::Borrowed("")
 }
diff --git a/apis/src/openai/responses/compact/tests.rs b/apis/src/openai/responses/compact/tests.rs
index 91532ee316..a537a8e6bb 100644
--- a/apis/src/openai/responses/compact/tests.rs
+++ b/apis/src/openai/responses/compact/tests.rs
@@ -17,6 +17,7 @@ fn base_config() -> CompactFilterConfig {
         inference_url: "http://localhost:11434/v1/chat/completions".to_owned(),
         default_model: "gpt-4o-mini".to_owned(),
         tiktoken_encoding: "cl100k_base".to_owned(),
+        summary_prefix: None,
         timeout_ms: None,
         on_failure: None,
         status_on_error: None,
@@ -216,7 +217,6 @@ fn extract_compaction_config_non_string_model_returns_error() {
     assert!(err.contains("compaction_model"));
 }
 
-
 // =============================================================================
 // build_compaction_item tests
 // =============================================================================
@@ -224,12 +224,39 @@ fn extract_compaction_config_non_string_model_returns_error() {
 #[test]
 fn compaction_item_has_correct_shape() {
     use base64::Engine as _;
-    let item = build_compaction_item("compact_abc123", "This is a summary.");
+    let item = build_compaction_item("compact_abc123", "This is a summary.", DEFAULT_SUMMARY_PREFIX);
     assert_eq!(item["type"], "compaction");
     assert_eq!(item["id"], "compact_abc123");
     let encoded = item["encrypted_content"].as_str().unwrap();
     let decoded = base64::engine::general_purpose::STANDARD.decode(encoded).unwrap();
     assert_eq!(String::from_utf8(decoded).unwrap(), "This is a summary.");
+    assert!(
+        item.get("summary_prefix").is_none(),
+        "default prefix should not be stored in the item"
+    );
+}
+
+#[test]
+fn compaction_item_with_custom_prefix() {
+    let item = build_compaction_item("compact_custom", "Summary.", "Context:\n");
+    assert_eq!(
+        item["summary_prefix"], "Context:\n",
+        "custom prefix should be stored in the item"
+    );
+}
+
+#[test]
+fn build_config_applies_default_summary_prefix() {
+    let cfg = build_config(&base_config()).unwrap();
+    assert_eq!(cfg.summary_prefix, DEFAULT_SUMMARY_PREFIX);
+}
+
+#[test]
+fn build_config_applies_custom_summary_prefix() {
+    let mut cfg = base_config();
+    cfg.summary_prefix = Some("Summary:\n".to_owned());
+    let validated = build_config(&cfg).unwrap();
+    assert_eq!(validated.summary_prefix, "Summary:\n");
 }
 
 // =============================================================================
@@ -387,6 +414,7 @@ fn replace_messages_preserves_current_input() {
         "model": "gpt-4o",
         "input": "What's next?"
     }));
+    state.history_rehydrated = true;
     state
         .messages
         .insert(0, json!({"role": "user", "content": "old question"}));
@@ -400,7 +428,7 @@ fn replace_messages_preserves_current_input() {
         .persisted_messages
         .insert(1, json!({"role": "assistant", "content": "old answer"}));
 
-    let compaction_item = build_compaction_item("compact_test", "Summary of old conversation.");
+    let compaction_item = build_compaction_item("compact_test", "Summary of old conversation.", DEFAULT_SUMMARY_PREFIX);
     replace_messages(&mut state, compaction_item);
 
     assert_eq!(state.messages.len(), 2, "should have compaction + current input");
@@ -411,6 +439,26 @@ fn replace_messages_preserves_current_input() {
     assert_eq!(state.persisted_messages[0]["type"], "compaction");
 }
 
+#[test]
+fn replace_messages_direct_input_does_not_duplicate_conversation() {
+    let mut state = ResponsesState::from_request_body(json!({
+        "model": "gpt-4o",
+        "input": [
+            {"role": "user", "content": "first"},
+            {"role": "assistant", "content": "second"},
+            {"role": "user", "content": "third"}
+        ]
+    }));
+    assert_eq!(state.input, state.messages, "direct input: input == messages");
+
+    let compaction_item = build_compaction_item("compact_direct", "Summary.", DEFAULT_SUMMARY_PREFIX);
+    replace_messages(&mut state, compaction_item);
+
+    assert_eq!(state.messages.len(), 1, "direct input should only have compaction item");
+    assert_eq!(state.messages[0]["type"], "compaction");
+    assert_eq!(state.persisted_messages.len(), 1);
+}
+
 // =============================================================================
 // get_token_count tests
 // =============================================================================
@@ -479,7 +527,7 @@ fn conversation_text_full_tool_round_trip() {
 
 #[test]
 fn conversation_text_includes_compaction_summary() {
-    let item = build_compaction_item("compact_1", "Prior context about widgets.");
+    let item = build_compaction_item("compact_1", "Prior context about widgets.", DEFAULT_SUMMARY_PREFIX);
     let messages = vec![item, json!({"role": "user", "content": "Tell me more"})];
     let text = build_conversation_text(&messages);
     assert!(text.contains("[previous context summary]: Prior context about widgets."));
@@ -488,7 +536,7 @@ fn conversation_text_includes_compaction_summary() {
 
 #[test]
 fn conversation_text_skips_empty_compaction_summary() {
-    let item = build_compaction_item("compact_2", "");
+    let item = build_compaction_item("compact_2", "", DEFAULT_SUMMARY_PREFIX);
     let messages = vec![item, json!({"role": "user", "content": "Hello"})];
     let text = build_conversation_text(&messages);
     assert!(!text.contains("context summary"));
@@ -578,75 +626,84 @@ fn non_2xx_response_closed_mode_rejects_request() {
 }
 
 // =============================================================================
-// build_context_overhead_text tests
+// previous_usage fast-path
 // =============================================================================
 
 #[test]
-fn overhead_text_empty_without_instructions_or_tools() {
-    let state = ResponsesState::from_request_body(json!({
-        "model": "gpt-4o",
-        "input": "Hello"
-    }));
-    assert!(build_context_overhead_text(&state).is_empty());
+fn previous_usage_total_returns_total_tokens() {
+    let mut state = ResponsesState::from_request_body(json!({"model": "gpt-4o", "input": "Hi"}));
+    state.previous_usage = Some(json!({"input_tokens": 100, "output_tokens": 50, "total_tokens": 150}));
+    assert_eq!(previous_usage_total(&state), Some(150));
 }
 
 #[test]
-fn overhead_text_includes_instructions() {
-    let state = ResponsesState::from_request_body(json!({
+fn previous_usage_total_returns_none_when_absent() {
+    let state = ResponsesState::from_request_body(json!({"model": "gpt-4o", "input": "Hi"}));
+    assert_eq!(previous_usage_total(&state), None);
+}
+
+#[test]
+fn previous_usage_total_returns_none_when_null() {
+    let mut state = ResponsesState::from_request_body(json!({"model": "gpt-4o", "input": "Hi"}));
+    state.previous_usage = Some(json!({"input_tokens": 100}));
+    assert_eq!(previous_usage_total(&state), None);
+}
+
+#[test]
+fn should_compact_uses_previous_usage_when_available() {
+    let mut state = ResponsesState::from_request_body(json!({
         "model": "gpt-4o",
         "input": "Hello",
-        "instructions": "You are a helpful assistant."
+        "context_management": [{"type": "compaction", "compact_threshold": 1000}]
     }));
-    let text = build_context_overhead_text(&state);
-    assert!(text.contains("You are a helpful assistant."));
+    state.messages = vec![json!({"role": "user", "content": "Hi"})];
+    state.previous_usage = Some(json!({"total_tokens": 2000}));
+    let result = should_compact(&state, "cl100k_base").unwrap();
+    assert!(result.is_some(), "should compact when previous_usage exceeds threshold");
 }
 
 #[test]
-fn overhead_text_includes_tool_definitions() {
-    let state = ResponsesState::from_request_body(json!({
+fn should_compact_skips_when_previous_usage_below_threshold() {
+    let mut state = ResponsesState::from_request_body(json!({
         "model": "gpt-4o",
         "input": "Hello",
-        "tools": [{
-            "type": "function",
-            "name": "get_weather",
-            "description": "Get the current weather for a location",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "location": {"type": "string", "description": "City name"}
-                },
-                "required": ["location"]
-            }
-        }]
+        "context_management": [{"type": "compaction", "compact_threshold": 1000}]
     }));
-    let text = build_context_overhead_text(&state);
-    assert!(text.contains("get_weather"));
+    state.messages = vec![json!({"role": "user", "content": "Hi"})];
+    state.previous_usage = Some(json!({"total_tokens": 500}));
+    let result = should_compact(&state, "cl100k_base").unwrap();
+    assert!(result.is_none(), "should skip when previous_usage is below threshold");
 }
 
+// =============================================================================
+// direct input should_compact
+// =============================================================================
+
 #[test]
-fn overhead_text_includes_both_instructions_and_tools() {
+fn direct_input_should_compact_uses_tiktoken() {
     let state = ResponsesState::from_request_body(json!({
         "model": "gpt-4o",
-        "input": "Hello",
-        "instructions": "Be concise.",
-        "tools": [{"type": "function", "name": "search", "parameters": {}}]
+        "input": [
+            {"role": "user", "content": "word ".repeat(3000)}
+        ],
+        "context_management": [{"type": "compaction", "compact_threshold": 1000}]
     }));
-    let text = build_context_overhead_text(&state);
-    assert!(text.contains("Be concise."));
-    assert!(text.contains("search"));
+    let result = should_compact(&state, "cl100k_base").unwrap();
+    assert!(
+        result.is_some(),
+        "direct input exceeding threshold should trigger compaction"
+    );
 }
 
 #[test]
-fn overhead_tokens_count_with_get_token_count() {
+fn direct_input_should_not_compact_below_threshold() {
     let state = ResponsesState::from_request_body(json!({
         "model": "gpt-4o",
-        "input": "Hello",
-        "instructions": "You are a helpful assistant that answers questions concisely."
+        "input": [{"role": "user", "content": "Hi"}],
+        "context_management": [{"type": "compaction", "compact_threshold": 50000}]
     }));
-    let text = build_context_overhead_text(&state);
-    let count = get_token_count(&text, "cl100k_base");
-    assert!(count.is_some());
-    assert!(count.unwrap() > 0);
+    let result = should_compact(&state, "cl100k_base").unwrap();
+    assert!(result.is_none(), "direct input below threshold should skip compaction");
 }
 
 #[test]
@@ -662,10 +719,132 @@ fn should_compact_accounts_for_overhead() {
     let result = should_compact(&state, "cl100k_base").unwrap();
     assert!(
         result.is_some(),
-        "overhead from long instructions should push total above threshold"
+        "tiktoken path should include instructions and tool definitions in token count"
+    );
+}
+
+#[test]
+fn tiktoken_fallback_includes_instructions_and_tools_in_count() {
+    let state = ResponsesState::from_request_body(json!({
+        "model": "gpt-4o",
+        "input": [{"role": "user", "content": "short"}],
+        "instructions": "Very long system prompt ".repeat(5000),
+        "tools": [{"type": "function", "name": "f", "description": "d ".repeat(5000)}],
+        "context_management": [{"type": "compaction", "compact_threshold": 1000}]
+    }));
+    let result = should_compact(&state, "cl100k_base").unwrap();
+    assert!(
+        result.is_some(),
+        "tiktoken path should include instructions and tool definitions in token count"
     );
 }
 
+// =============================================================================
+// parse_compact_request_body
+// =============================================================================
+
+#[test]
+fn parse_compact_request_body_valid() {
+    let body = Some(Bytes::from(
+        serde_json::to_vec(&json!({
+            "response_id": "resp_abc",
+            "model": "gpt-4o",
+            "instructions": "Be concise"
+        }))
+        .unwrap(),
+    ));
+    let req = parse_compact_request_body(&body).unwrap();
+    assert_eq!(req.response_id, "resp_abc");
+    assert_eq!(req.model.as_deref(), Some("gpt-4o"));
+    assert_eq!(req.instructions.as_deref(), Some("Be concise"));
+}
+
+#[test]
+fn parse_compact_request_body_minimal() {
+    let body = Some(Bytes::from(
+        serde_json::to_vec(&json!({"response_id": "resp_xyz"})).unwrap(),
+    ));
+    let req = parse_compact_request_body(&body).unwrap();
+    assert_eq!(req.response_id, "resp_xyz");
+    assert!(req.model.is_none());
+    assert!(req.instructions.is_none());
+}
+
+#[test]
+fn parse_compact_request_body_empty() {
+    assert!(parse_compact_request_body(&None).is_err());
+}
+
+#[test]
+fn parse_compact_request_body_invalid_json() {
+    let body = Some(Bytes::from_static(b"not json"));
+    assert!(parse_compact_request_body(&body).is_err());
+}
+
+#[test]
+fn parse_compact_request_body_missing_response_id() {
+    let body = Some(Bytes::from(serde_json::to_vec(&json!({"model": "gpt-4o"})).unwrap()));
+    assert!(parse_compact_request_body(&body).is_err());
+}
+
+#[test]
+fn parse_compact_request_body_empty_response_id() {
+    let body = Some(Bytes::from(
+        serde_json::to_vec(&json!({"response_id": "", "model": "gpt-4o"})).unwrap(),
+    ));
+    assert!(parse_compact_request_body(&body).is_err());
+}
+
+// =============================================================================
+// extract_stored_messages
+// =============================================================================
+
+#[test]
+fn extract_stored_messages_returns_messages() {
+    let record = ResponseRecord {
+        id: "resp_1".to_owned(),
+        tenant_id: "default".to_owned(),
+        created_at: 0,
+        model: "gpt-4o".to_owned(),
+        response_object: json!({}),
+        input: json!([]),
+        messages: json!([
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi"}
+        ]),
+    };
+    let msgs = extract_stored_messages(record).unwrap();
+    assert_eq!(msgs.len(), 2);
+}
+
+#[test]
+fn extract_stored_messages_empty_array() {
+    let record = ResponseRecord {
+        id: "resp_1".to_owned(),
+        tenant_id: "default".to_owned(),
+        created_at: 0,
+        model: "gpt-4o".to_owned(),
+        response_object: json!({}),
+        input: json!([]),
+        messages: json!([]),
+    };
+    assert!(extract_stored_messages(record).is_err());
+}
+
+#[test]
+fn extract_stored_messages_not_array() {
+    let record = ResponseRecord {
+        id: "resp_1".to_owned(),
+        tenant_id: "default".to_owned(),
+        created_at: 0,
+        model: "gpt-4o".to_owned(),
+        response_object: json!({}),
+        input: json!([]),
+        messages: json!("not an array"),
+    };
+    assert!(extract_stored_messages(record).is_err());
+}
+
 // =============================================================================
 // canonical round-trip
 // =============================================================================
@@ -673,7 +852,7 @@ fn should_compact_accounts_for_overhead() {
 #[test]
 fn compaction_item_round_trips_through_canonical_replay() {
     use crate::openai::responses::canonical_openresponses_replay_item;
-    let item = build_compaction_item("compact_rt", "Summary text.");
+    let item = build_compaction_item("compact_rt", "Summary text.", DEFAULT_SUMMARY_PREFIX);
     let replayed = canonical_openresponses_replay_item(&item);
     assert!(replayed.is_some(), "compaction item should be replayable");
     let replayed = replayed.unwrap();
@@ -681,3 +860,53 @@ fn compaction_item_round_trips_through_canonical_replay() {
     assert_eq!(replayed["id"], "compact_rt");
     assert!(replayed.get("encrypted_content").is_some());
 }
+
+// =============================================================================
+// is_compactable tests
+// =============================================================================
+
+#[test]
+fn is_compactable_returns_false_when_no_state() {
+    assert!(!is_compactable(None));
+}
+
+#[test]
+fn is_compactable_returns_true_when_rehydrated() {
+    let mut state = ResponsesState::from_request_body(json!({
+        "model": "gpt-4o",
+        "input": "Hello"
+    }));
+    state.history_rehydrated = true;
+    assert!(is_compactable(Some(&state)));
+}
+
+#[test]
+fn is_compactable_returns_false_for_direct_input_with_compaction_config() {
+    let state = ResponsesState::from_request_body(json!({
+        "model": "gpt-4o",
+        "input": [{"role": "user", "content": "Hello"}],
+        "context_management": [{"type": "compaction", "compact_threshold": 100}]
+    }));
+    assert!(!state.history_rehydrated, "precondition: not rehydrated");
+    assert!(!is_compactable(Some(&state)));
+}
+
+#[test]
+fn is_compactable_returns_false_without_rehydration_or_config() {
+    let state = ResponsesState::from_request_body(json!({
+        "model": "gpt-4o",
+        "input": "Hello"
+    }));
+    assert!(!state.history_rehydrated, "precondition: not rehydrated");
+    assert!(!is_compactable(Some(&state)));
+}
+
+#[test]
+fn is_compactable_returns_false_with_non_compaction_config() {
+    let state = ResponsesState::from_request_body(json!({
+        "model": "gpt-4o",
+        "input": "Hello",
+        "context_management": [{"type": "truncation", "max_tokens": 4096}]
+    }));
+    assert!(!is_compactable(Some(&state)));
+}
diff --git a/apis/src/openai/responses/openai_responses_proxy/mod.rs b/apis/src/openai/responses/openai_responses_proxy/mod.rs
index e806d239a5..f69085ceb9 100644
--- a/apis/src/openai/responses/openai_responses_proxy/mod.rs
+++ b/apis/src/openai/responses/openai_responses_proxy/mod.rs
@@ -348,9 +348,13 @@ fn compaction_to_assistant_message(m: &serde_json::Value) -> serde_json::Value {
         .and_then(|e| base64::engine::general_purpose::STANDARD.decode(e).ok())
         .and_then(|b| String::from_utf8(b).ok())
         .unwrap_or_default();
+    let prefix = m
+        .get("summary_prefix")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or(super::compact::DEFAULT_SUMMARY_PREFIX);
     serde_json::json!({
         "role": "assistant",
-        "content": format!("[Previous conversation summary]\n\n{summary}")
+        "content": format!("{prefix}{summary}")
     })
 }
 
diff --git a/apis/src/openai/responses/store/filter.rs b/apis/src/openai/responses/store/filter.rs
index 6e63b5509d..9ec4e0ecec 100644
--- a/apis/src/openai/responses/store/filter.rs
+++ b/apis/src/openai/responses/store/filter.rs
@@ -60,7 +60,7 @@ use tracing::{debug, trace, warn};
 use super::{
     super::{
         DEFAULT_STORE_NAME, DEFAULT_TENANT_ID, TENANT_METADATA_KEY, append_stored_input_items,
-        error::responses_error_rejection, state::ResponsesState,
+        compact::is_explicit_compact_request, error::responses_error_rejection, state::ResponsesState,
     },
     InputItemPage, ListParams, MAX_PAGE_LIMIT, Order,
     config::{ResponseStoreConfig, StorageBackend, revalidate_postgres_host, validate_config},
@@ -214,6 +214,18 @@ impl ResponseStoreFilter {
         }
     }
 
+    /// Best-effort store init for the explicit compact endpoint.
+    ///
+    /// The compact filter handles a missing store with its own error,
+    /// so a failed init here does not reject the request.
+    async fn try_init_store_for_compact(&self, ctx: &HttpFilterContext<'_>) {
+        if is_explicit_compact_request(ctx)
+            && let Some(store) = &self.get_or_init_store().await
+        {
+            register_store_in_context(ctx, store);
+        }
+    }
+
     /// Handle `DELETE /v1/responses/{id}` by deleting from the store.
     async fn handle_delete(&self, tenant_id: &str, id: &str) -> Result<FilterAction, FilterError> {
         let Some(store) = self.ensure_store().await else {
@@ -725,6 +737,7 @@ impl HttpFilter for ResponseStoreFilter {
         }
 
         if !should_init_store_for_request(ctx) {
+            self.try_init_store_for_compact(ctx).await;
             return Ok(FilterAction::Continue);
         }
 
@@ -758,6 +771,8 @@ impl HttpFilter for ResponseStoreFilter {
                 Some(store) => register_store_in_context(ctx, store),
                 None => return Ok(FilterAction::Reject(reject_store_error())),
             }
+        } else {
+            self.try_init_store_for_compact(ctx).await;
         }
         Ok(FilterAction::Continue)
     }
diff --git a/apis/src/openai/responses/store/input_items.rs b/apis/src/openai/responses/store/input_items.rs
index 66169219b2..fb5965a7f9 100644
--- a/apis/src/openai/responses/store/input_items.rs
+++ b/apis/src/openai/responses/store/input_items.rs
@@ -163,12 +163,18 @@ fn normalize_input_items(record: &ResponseRecord) -> Vec<serde_json::Value> {
     let items = match &record.input {
         serde_json::Value::Null => vec![],
         serde_json::Value::String(text) => vec![scalar_input_item(&record.id, text)],
-        serde_json::Value::Array(arr) => arr.clone(),
+        serde_json::Value::Array(arr) => arr.iter().filter(|item| !is_compaction_item(item)).cloned().collect(),
         other => vec![other.clone()],
     };
     ensure_stable_ids(&record.id, items)
 }
 
+/// Returns `true` for internal compaction items that should be hidden
+/// from the public `input_items` API.
+fn is_compaction_item(item: &serde_json::Value) -> bool {
+    item.get("type").and_then(serde_json::Value::as_str) == Some("compaction")
+}
+
 /// Assign a stable synthetic ID (`msg_{response_id}_input_{index}`) to
 /// any item missing one, keyed by its position in the original stored
 /// input order (before any order-based reversal).
diff --git a/apis/src/openai/responses/store/tests.rs b/apis/src/openai/responses/store/tests.rs
index d7c56cfa44..7b0f8bc7e0 100644
--- a/apis/src/openai/responses/store/tests.rs
+++ b/apis/src/openai/responses/store/tests.rs
@@ -3360,6 +3360,41 @@ async fn get_input_items_pagination_usable_for_id_less_array_items() {
     assert_eq!(follow_up_body["has_more"], false);
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn get_input_items_hides_compaction_items() {
+    let filter = make_filter();
+    init_store_and_seed(
+        &filter,
+        "resp_compact_hidden",
+        "default",
+        json!([
+            {"type": "compaction", "id": "compact_1", "encrypted_content": "c3VtbWFyeQ=="},
+            {"type": "message", "role": "user", "content": "hello"}
+        ]),
+    )
+    .await;
+
+    let req = crate::test_utils::make_request(
+        http::Method::GET,
+        "/v1/responses/resp_compact_hidden/input_items?order=asc",
+    );
+    let mut ctx = crate::test_utils::make_filter_context(&req);
+    let action = filter.on_request(&mut ctx).await.unwrap();
+    let rejection = expect_reject(action);
+    assert_eq!(rejection.status, 200);
+
+    let body: serde_json::Value = serde_json::from_slice(rejection.body.as_deref().unwrap()).unwrap();
+    let data = body["data"].as_array().unwrap();
+    assert_eq!(data.len(), 1, "compaction item should be hidden");
+    assert_eq!(data[0]["content"], "hello");
+    assert!(
+        !data
+            .iter()
+            .any(|item| item.get("type").and_then(|t| t.as_str()) == Some("compaction")),
+        "no compaction items should appear in input_items"
+    );
+}
+
 // -----------------------------------------------------------------------------
 // DELETE
 // -----------------------------------------------------------------------------
diff --git a/apis/src/openai/translation/chat_completions.rs b/apis/src/openai/translation/chat_completions.rs
index c4f6c5e30d..68df13ed90 100644
--- a/apis/src/openai/translation/chat_completions.rs
+++ b/apis/src/openai/translation/chat_completions.rs
@@ -559,9 +559,13 @@ fn append_compaction_item(messages: &mut Vec<Value>, obj: &Map<String, Value>) {
         .and_then(|b| String::from_utf8(b).ok())
         .unwrap_or_default();
     if !summary.is_empty() {
+        let prefix = obj
+            .get("summary_prefix")
+            .and_then(Value::as_str)
+            .unwrap_or(crate::openai::responses::compact::DEFAULT_SUMMARY_PREFIX);
         messages.push(json!({
             "role": "assistant",
-            "content": format!("[Previous conversation summary]\n\n{summary}")
+            "content": format!("{prefix}{summary}")
         }));
     }
 }
diff --git a/docs/filters/openai_responses_compact.md b/docs/filters/openai_responses_compact.md
index 7fe7e7987d..70d95e19bd 100644
--- a/docs/filters/openai_responses_compact.md
+++ b/docs/filters/openai_responses_compact.md
@@ -9,7 +9,13 @@ Summarizes conversation history when the token count exceeds a configured thresh
 
 `compact_threshold` in `context_management` must be an integer of at least 1000. Invalid or missing `compact_threshold` values produce an `invalid_request_error`.
 
-Compaction only applies to multi-turn requests where `openai_responses_rehydrate` has loaded stored conversation history. Single-turn requests are released without compaction.
+Compaction applies in two scenarios:
+
+- **Rehydrated history** — stored history loaded via `previous_response_id` or `conversation`. Only the stored history is summarized; the current turn is preserved.
+
+- **Explicit compact** — `POST /v1/responses/compact` with a `response_id`. Loads stored messages, summarizes them, and persists a new compacted response.
+
+Direct input requests (full conversation in `input` with no stored history) skip reactive compaction because `state.input == state.messages` — there is no separable "current turn" to preserve after summarization. Requests without rehydrated history are released without compaction.
 
 Praxis runs `StreamBuffer` body hooks before header-phase request filters. This filter therefore requires `allow_pre_security_callout: true` and should only be used behind an outer authentication and authorization boundary.
 
@@ -22,6 +28,7 @@ Praxis runs `StreamBuffer` body hooks before header-phase request filters. This
 | `allow_private_inference_url` | bool | no | Allow the inference target to resolve to non-public addresses. |
 | `default_model` | string | no | Default model for summarization when not overridden in the request's `context_management`. |
 | `tiktoken_encoding` | string | no | Tiktoken encoding name for local token estimation of the conversation text. |
+| `summary_prefix` | string | no | Prefix prepended to the summary when translating compaction items to backend messages. Defaults to `"[Previous conversation summary]\n\n"`. |
 | `timeout_ms` | integer | no | Callout timeout in milliseconds. |
 | `on_failure` | `closed` \| `open` | no | Failure mode for the inference callout. |
 | `status_on_error` | integer | no | HTTP error status code (`400..=599`) to return when rejecting on error. |
@@ -47,6 +54,7 @@ inference_url: "http://localhost:11434/v1/chat/completions"
 allow_private_inference_url: true
 default_model: gpt-4o-mini
 tiktoken_encoding: cl100k_base
+summary_prefix: "[Previous conversation summary]\n\n"
 timeout_ms: 30000
 on_failure: closed
 status_on_error: 502
diff --git a/tests/integration/tests/suite/examples/compact.rs b/tests/integration/tests/suite/examples/compact.rs
index f60cc075b0..ee38a06d26 100644
--- a/tests/integration/tests/suite/examples/compact.rs
+++ b/tests/integration/tests/suite/examples/compact.rs
@@ -15,8 +15,8 @@ use std::{
 };
 
 use praxis_test_utils::{
-    Backend, TempSqlite, bind_unique_port, example_config_path, free_port, http_send, json_post, parse_status,
-    patch_yaml, start_proxy,
+    Backend, TempSqlite, bind_unique_port, example_config_path, free_port, http_send, json_post, parse_body,
+    parse_status, patch_yaml, start_proxy,
 };
 
 // -----------------------------------------------------------------------------
@@ -276,23 +276,41 @@ async fn compact_verifies_summarization_call_and_compacted_state() {
     );
 }
 
-#[test]
-fn compact_rejects_invalid_compact_threshold() {
-    let backend_guard = Backend::fixed(FIRST_RESPONSE_JSON)
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_rejects_invalid_compact_threshold() {
+    // Phase 1: store a response so the second turn rehydrates history and
+    // the compact filter actually evaluates the compaction config.
+    let backend1 = Backend::fixed(FIRST_RESPONSE_JSON)
         .header("content-type", "application/json")
         .start_with_shutdown();
     let proxy_port = free_port();
-
+    let db = TempSqlite::new("compact_invalid_threshold");
     let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
         .expect("example config should exist");
-    let config = load_compact_config(&yaml, "sqlite::memory:", proxy_port, backend_guard.port());
-    let proxy = start_proxy(&config);
+
+    let config1 = load_compact_config(&yaml, db.url(), proxy_port, backend1.port());
+    let proxy1 = start_proxy(&config1);
+    let raw1 = http_send(
+        proxy1.addr(),
+        &json_post("/v1/responses", r#"{"model":"gpt-4.1","input":"Explain TCP vs UDP"}"#),
+    );
+    assert_eq!(parse_status(&raw1), 200, "first request should store response");
+    drop(backend1);
+    drop(proxy1);
+
+    // Phase 2: a rehydrated request with a below-minimum threshold must be
+    // rejected before any summarization callout.
+    let backend2 = Backend::fixed(CHAT_COMPLETIONS_RESPONSE)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend2.port());
+    let proxy2 = start_proxy(&config2);
 
     let raw = http_send(
-        proxy.addr(),
+        proxy2.addr(),
         &json_post(
             "/v1/responses",
-            r#"{"model":"gpt-4.1","input":"Compare with QUIC","context_management":[{"type":"compaction","compact_threshold":50}]}"#,
+            r#"{"model":"gpt-4.1","input":"Compare with QUIC","previous_response_id":"resp_compact","context_management":[{"type":"compaction","compact_threshold":50}]}"#,
         ),
     );
 
@@ -305,4 +323,91 @@ fn compact_rejects_invalid_compact_threshold() {
         raw.contains("at least 1000"),
         "response should explain threshold requirement: {raw}"
     );
+    drop(proxy2);
+}
+
+#[test]
+fn compact_direct_input_skips_reactive_compaction() {
+    let backend = Backend::fixed(FIRST_RESPONSE_JSON)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+    let config = load_compact_config(&yaml, "sqlite::memory:", proxy_port, backend.port());
+    let proxy = start_proxy(&config);
+
+    // Send a full conversation in `input` with context_management but
+    // no previous_response_id. Reactive compaction is skipped because
+    // state.input == state.messages — there is no separable "current
+    // turn" to preserve after summarization.
+    let raw = http_send(
+        proxy.addr(),
+        &json_post(
+            "/v1/responses",
+            r#"{"model":"gpt-4.1","input":[{"role":"user","content":"Explain TCP vs UDP in detail"},{"role":"assistant","content":"TCP is a connection-oriented protocol."},{"role":"user","content":"Compare with QUIC"}],"context_management":[{"type":"compaction","compact_threshold":50}]}"#,
+        ),
+    );
+    assert_eq!(
+        parse_status(&raw),
+        200,
+        "direct input without rehydration should pass through without compaction"
+    );
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_explicit_endpoint() {
+    // Phase 1: store a response via normal inference.
+    let backend1 = Backend::fixed(FIRST_RESPONSE_JSON)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let db = TempSqlite::new("compact_explicit");
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+
+    let config1 = load_compact_config(&yaml, db.url(), proxy_port, backend1.port());
+    let proxy1 = start_proxy(&config1);
+    let raw1 = http_send(
+        proxy1.addr(),
+        &json_post("/v1/responses", r#"{"model":"gpt-4.1","input":"Explain TCP vs UDP"}"#),
+    );
+    assert_eq!(parse_status(&raw1), 200, "first request should store response");
+    drop(backend1);
+    drop(proxy1);
+
+    // Phase 2: POST /v1/responses/compact with the stored response_id.
+    // The summarization callout goes to inference_url (same backend address).
+    let backend2 = Backend::fixed(CHAT_COMPLETIONS_RESPONSE)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend2.port());
+    let proxy2 = start_proxy(&config2);
+
+    let raw2 = http_send(
+        proxy2.addr(),
+        &json_post(
+            "/v1/responses/compact",
+            r#"{"response_id":"resp_compact","model":"gpt-4.1"}"#,
+        ),
+    );
+    assert_eq!(parse_status(&raw2), 200, "explicit compact should return 200");
+
+    let body = parse_body(&raw2);
+    let resp: serde_json::Value = serde_json::from_str(&body).expect("response should be valid JSON");
+    assert_eq!(resp["object"], "response", "should be a response object");
+    assert_eq!(resp["status"], "completed");
+    assert_eq!(
+        resp["previous_response_id"], "resp_compact",
+        "should reference the original response"
+    );
+    let output = resp["output"].as_array().expect("output should be an array");
+    assert_eq!(output.len(), 1, "output should have one compaction item");
+    assert_eq!(output[0]["type"], "compaction");
+    assert!(
+        output[0].get("encrypted_content").is_some(),
+        "compaction item should have encrypted_content"
+    );
+    drop(proxy2);
 }

From a41ef0c0e241ca18bc0bbbe4d2e28e4c9ea34009 Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Wed, 9 Sep 2026 09:13:03 +0200
Subject: [PATCH 02/10] feat(compact): assert OpenAI contract and persisted DB
 state end-to-end.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs      | 365 +++++++++--------
 apis/src/openai/responses/compact/tests.rs    | 191 ++++++---
 docs/filters/openai_responses_compact.md      |   2 +-
 .../tests/suite/examples/compact.rs           | 369 +++++++++++++++++-
 4 files changed, 705 insertions(+), 222 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index 1b0e94e15b..2a4e3dd135 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -92,6 +92,14 @@ struct CompactionParams {
     compaction_model: Option<String>,
 }
 
+/// Result of a successful summarization callout.
+struct Summarization {
+    /// The generated summary text.
+    content: String,
+    /// The callout's Chat Completions `usage` object, when reported.
+    usage: Option<Value>,
+}
+
 // -----------------------------------------------------------------------------
 // CompactFilter
 // -----------------------------------------------------------------------------
@@ -108,8 +116,9 @@ struct CompactionParams {
 /// - **Rehydrated history** — stored history loaded via `previous_response_id` or `conversation`. Only the stored
 ///   history is summarized; the current turn is preserved.
 ///
-/// - **Explicit compact** — `POST /v1/responses/compact` with a `response_id`. Loads stored messages, summarizes them,
-///   and persists a new compacted response.
+/// - **Explicit compact** — `POST /v1/responses/compact` with a required `model` and an inline `input` conversation
+///   and/or a `previous_response_id`. Loads any stored history, appends the inline input, summarizes the combined
+///   conversation, and returns a `response.compaction` object (with `output` and `usage`) per the OpenAI contract.
 ///
 /// Direct input requests (full conversation in `input` with no stored history) skip reactive compaction because
 /// `state.input == state.messages` — there is no separable "current turn" to preserve after summarization.
@@ -186,10 +195,6 @@ impl CompactFilter {
     }
 
     /// Run the summarization callout and return the summary text.
-    ///
-    /// Returns `Ok(Some(summary))` on success, `Ok(None)` when
-    /// compaction should be skipped, or `Err(FilterAction)` to
-    /// short-circuit the request.
     async fn execute_compaction(
         &self,
         state: &ResponsesState,
@@ -210,15 +215,15 @@ impl CompactFilter {
             self.config.address_policy,
         )
         .await;
-        self.handle_subrequest_result(result, streaming)
+        Ok(self.handle_subrequest_result(result, streaming)?.map(|s| s.content))
     }
 
-    /// Map a subrequest result to a summary string or a filter action.
+    /// Map a subrequest result to a parsed summarization or a filter action.
     fn handle_subrequest_result(
         &self,
         result: Result<subrequest::SubResponse, subrequest::SubRequestError>,
         streaming: bool,
-    ) -> Result<Option<String>, FilterAction> {
+    ) -> Result<Option<Summarization>, FilterAction> {
         match result {
             Ok(resp) if (200..300).contains(&(resp.status as usize)) => {
                 parse_summarization_response(&resp.body).map(Some).or_else(|e| {
@@ -242,11 +247,9 @@ impl CompactFilter {
         &self,
         req: &ExplicitCompactRequest,
         messages: &[Value],
-    ) -> Result<String, FilterAction> {
+    ) -> Result<Option<Summarization>, FilterAction> {
         let conversation_text = build_conversation_text(messages);
-        let model = req.model.as_deref().unwrap_or(&self.config.default_model);
-        let instructions = req.instructions.as_deref();
-        let request = build_summarization_request(&conversation_text, instructions, model);
+        let request = build_summarization_request(&conversation_text, req.instructions.as_deref(), &req.model);
         let timeout = Duration::from_millis(self.config.callout.timeout_ms);
         let result = subrequest::execute_url(
             &self.client,
@@ -257,20 +260,11 @@ impl CompactFilter {
             self.config.address_policy,
         )
         .await;
-        match self.handle_subrequest_result(result, false) {
-            Ok(Some(s)) => Ok(s),
-            Ok(None) => Err(FilterAction::Reject(responses_error_rejection(
-                502,
-                "server_error",
-                "compaction callout failed",
-                false,
-            ))),
-            Err(action) => Err(action),
-        }
+        self.handle_subrequest_result(result, false)
     }
 
     /// Apply the configured open/closed policy on a callout error.
-    fn on_callout_error(&self, message: &str, streaming: bool) -> Result<Option<String>, FilterAction> {
+    fn on_callout_error(&self, message: &str, streaming: bool) -> Result<Option<Summarization>, FilterAction> {
         match self.config.callout.on_failure {
             OnFailure::Open => Ok(None),
             OnFailure::Closed => Err(FilterAction::Reject(responses_error_rejection(
@@ -282,46 +276,27 @@ impl CompactFilter {
         }
     }
 
-    /// Apply compaction results: replace messages and persist the
-    /// compaction response to the store.
-    async fn apply_compaction(&self, ctx: &mut HttpFilterContext<'_>, summary: &str, model: &str) {
+    /// Apply compaction results: replace the conversation history with
+    /// the compaction item. The compacted messages are persisted by the
+    /// normal response store filter as part of the eventual response.
+    fn apply_compaction(&self, ctx: &mut HttpFilterContext<'_>, summary: &str) {
         let compaction_id = format!("compact_{}", ctx.id_generator.generate(ctx.time_source));
-        let resp_id = format!("resp_{}", ctx.id_generator.generate(ctx.time_source));
-        let created_at = i64::try_from(ctx.time_source.now().as_secs()).unwrap_or(i64::MAX);
-        let store = ctx
-            .extensions
-            .get::<ResponseStoreRegistry>()
-            .and_then(|r| r.get("default"));
-        let tenant_id = ctx.get_metadata("responses.tenant_id").unwrap_or("default").to_owned();
-
-        // Mutate state and take an owned snapshot of the compacted messages,
-        // releasing the `&mut ResponsesState` borrow before the store await.
-        let persisted_messages = {
-            let Some(state) = ctx.extensions.get_mut::<ResponsesState>() else {
-                warn!("ResponsesState missing in apply_compaction");
-                return;
-            };
-            replace_messages(
-                state,
-                build_compaction_item(&compaction_id, summary, &self.config.summary_prefix),
-            );
-            state.persisted_messages.clone()
+        let Some(state) = ctx.extensions.get_mut::<ResponsesState>() else {
+            warn!("ResponsesState missing in apply_compaction");
+            return;
         };
-        if let Some(store) = store.as_deref() {
-            persist_compaction_response(store, &resp_id, model, &tenant_id, created_at, persisted_messages).await;
-        }
+        replace_messages(
+            state,
+            build_compaction_item(&compaction_id, summary, &self.config.summary_prefix),
+        );
     }
 
-    /// Check threshold and run summarization if exceeded.
-    ///
-    /// Returns `Ok(Some((summary, model)))` when compaction ran,
-    /// `Ok(None)` when skipped, or `Err(FilterAction)` to
-    /// short-circuit.
+    /// Check the threshold and run summarization if it is exceeded.
     async fn check_and_summarize(
         &self,
         state: &ResponsesState,
         streaming: bool,
-    ) -> Result<Option<(String, String)>, FilterAction> {
+    ) -> Result<Option<String>, FilterAction> {
         let (params, conversation_text) = match should_compact(state, &self.config.tiktoken_encoding) {
             Ok(Some(pair)) => pair,
             Ok(None) => return Ok(None),
@@ -330,18 +305,8 @@ impl CompactFilter {
                 return Err(FilterAction::Reject(rej));
             },
         };
-        let summary = match self
-            .execute_compaction(state, &params, streaming, &conversation_text)
+        self.execute_compaction(state, &params, streaming, &conversation_text)
             .await
-        {
-            Ok(Some(s)) => s,
-            Ok(None) => return Ok(None),
-            Err(action) => return Err(action),
-        };
-        let model = params
-            .compaction_model
-            .unwrap_or_else(|| self.config.default_model.clone());
-        Ok(Some((summary, model)))
     }
 
     /// Handle an explicit `POST /v1/responses/compact` request.
@@ -367,10 +332,10 @@ impl CompactFilter {
     ) -> Result<FilterAction, FilterAction> {
         let req = parse_compact_request_body(body)?;
         let (store, tenant_id) = resolve_store_and_tenant(ctx)?;
-        let record = fetch_response(&*store, &tenant_id, &req).await?;
-        let messages = extract_stored_messages(record)?;
+        let messages = collect_compact_messages(&*store, &tenant_id, &req).await?;
         let summary = self.summarize_messages(&req, &messages).await?;
-        let response_object = build_and_persist_compaction(self, ctx, &*store, &tenant_id, &req, &summary).await?;
+        let response_object =
+            build_and_persist_compaction(self, ctx, &*store, &tenant_id, &req, &messages, summary.as_ref()).await?;
         let body_bytes = serde_json::to_vec(&response_object).unwrap_or_default();
         Ok(FilterAction::Reject(
             praxis_filter::Rejection::status(200)
@@ -423,12 +388,12 @@ impl HttpFilter for CompactFilter {
             warn!("ResponsesState missing after ensure_compactable_state");
             return Ok(FilterAction::Release);
         };
-        let (summary, model) = match self.check_and_summarize(state, streaming).await {
-            Ok(Some(result)) => result,
+        let summary = match self.check_and_summarize(state, streaming).await {
+            Ok(Some(summary)) => summary,
             Ok(None) | Err(FilterAction::Release) => return Ok(FilterAction::Release),
             Err(action) => return Ok(action),
         };
-        self.apply_compaction(ctx, &summary, &model).await;
+        self.apply_compaction(ctx, &summary);
         ctx.set_metadata("responses.compacted", "true");
         Ok(FilterAction::Release)
     }
@@ -563,15 +528,18 @@ fn is_streaming(ctx: &HttpFilterContext<'_>) -> bool {
 
 /// Parsed body for `POST /v1/responses/compact`.
 struct ExplicitCompactRequest {
-    /// The stored response to compact.
-    response_id: String,
-    /// Optional model override for the summarization call.
-    model: Option<String>,
+    /// Required model for the compaction pass.
+    model: String,
+    /// Inline conversation items to compact (may be empty).
+    input: Vec<Value>,
+    /// Optional stored response whose history is loaded and compacted.
+    previous_response_id: Option<String>,
     /// Optional instructions to prepend to the summarization prompt.
     instructions: Option<String>,
 }
 
 /// Parse and validate the `POST /v1/responses/compact` body.
+#[expect(clippy::too_many_lines, reason = "linear field parsing and validation")]
 fn parse_compact_request_body(body: &Option<Bytes>) -> Result<ExplicitCompactRequest, FilterAction> {
     let bytes = body
         .as_ref()
@@ -581,15 +549,29 @@ fn parse_compact_request_body(body: &Option<Bytes>) -> Result<ExplicitCompactReq
         debug!(error = %e, "compact request body parse failed");
         reject_compact(400, "invalid_request_error", "invalid JSON body")
     })?;
-    let response_id = parsed
-        .get("response_id")
+    let model = parsed
+        .get("model")
         .and_then(Value::as_str)
         .filter(|s| !s.is_empty())
-        .ok_or_else(|| reject_compact(400, "invalid_request_error", "missing required field: response_id"))?
+        .ok_or_else(|| reject_compact(400, "invalid_request_error", "missing required field: model"))?
         .to_owned();
+    let input = parse_compact_input(parsed.get("input"));
+    let previous_response_id = parsed
+        .get("previous_response_id")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .map(ToOwned::to_owned);
+    if input.is_empty() && previous_response_id.is_none() {
+        return Err(reject_compact(
+            400,
+            "invalid_request_error",
+            "request must include input or previous_response_id",
+        ));
+    }
     Ok(ExplicitCompactRequest {
-        response_id,
-        model: parsed.get("model").and_then(Value::as_str).map(ToOwned::to_owned),
+        model,
+        input,
+        previous_response_id,
         instructions: parsed
             .get("instructions")
             .and_then(Value::as_str)
@@ -597,6 +579,20 @@ fn parse_compact_request_body(body: &Option<Bytes>) -> Result<ExplicitCompactReq
     })
 }
 
+/// Normalize the `input` field into a list of conversation items.
+///
+/// A bare string is coerced into a single `user` message, matching the
+/// contract where a string is equivalent to a text user input.
+fn parse_compact_input(input: Option<&Value>) -> Vec<Value> {
+    match input {
+        Some(Value::String(s)) if !s.is_empty() => {
+            vec![serde_json::json!({"role": "user", "content": s})]
+        },
+        Some(Value::Array(arr)) => arr.clone(),
+        _ => Vec::new(),
+    }
+}
+
 /// Look up the store and tenant from the request context.
 fn resolve_store_and_tenant(
     ctx: &HttpFilterContext<'_>,
@@ -610,13 +606,34 @@ fn resolve_store_and_tenant(
     Ok((store, tenant_id))
 }
 
-/// Fetch a stored response.
-async fn fetch_response(
+/// Assemble the conversation to compact from stored history and inline input.
+///
+/// When `previous_response_id` is set, its stored messages are loaded
+/// first and the inline `input` items are appended after.
+async fn collect_compact_messages(
     store: &dyn crate::store::ResponseStore,
     tenant_id: &str,
     req: &ExplicitCompactRequest,
+) -> Result<Vec<Value>, FilterAction> {
+    let mut messages = Vec::new();
+    if let Some(prev) = req.previous_response_id.as_deref() {
+        let record = fetch_response(store, tenant_id, prev).await?;
+        messages.extend(stored_message_array(record.messages));
+    }
+    messages.extend(req.input.iter().cloned());
+    if messages.is_empty() {
+        return Err(reject_compact(400, "invalid_request_error", "no messages to compact"));
+    }
+    Ok(messages)
+}
+
+/// Fetch a stored response by id.
+async fn fetch_response(
+    store: &dyn crate::store::ResponseStore,
+    tenant_id: &str,
+    response_id: &str,
 ) -> Result<ResponseRecord, FilterAction> {
-    match store.get_response(tenant_id, &req.response_id).await {
+    match store.get_response(tenant_id, response_id).await {
         Ok(Some(r)) => Ok(r),
         Ok(None) => Err(reject_compact(404, "not_found_error", "response not found")),
         Err(e) => {
@@ -626,15 +643,11 @@ async fn fetch_response(
     }
 }
 
-/// Extract messages from a stored response.
-fn extract_stored_messages(record: ResponseRecord) -> Result<Vec<Value>, FilterAction> {
-    match record.messages {
-        Value::Array(arr) if !arr.is_empty() => Ok(arr),
-        _ => Err(reject_compact(
-            400,
-            "invalid_request_error",
-            "response has no messages to compact",
-        )),
+/// Extract a stored record's messages as an array, or an empty list.
+fn stored_message_array(messages: Value) -> Vec<Value> {
+    match messages {
+        Value::Array(arr) => arr,
+        _ => Vec::new(),
     }
 }
 
@@ -642,7 +655,7 @@ fn extract_stored_messages(record: ResponseRecord) -> Result<Vec<Value>, FilterA
 #[expect(
     clippy::too_many_arguments,
     clippy::too_many_lines,
-    reason = "all parameters are needed"
+    reason = "all parameters are needed to build and persist the record"
 )]
 async fn build_and_persist_compaction(
     filter: &CompactFilter,
@@ -650,32 +663,40 @@ async fn build_and_persist_compaction(
     store: &dyn crate::store::ResponseStore,
     tenant_id: &str,
     req: &ExplicitCompactRequest,
-    summary: &str,
+    messages: &[Value],
+    summary: Option<&Summarization>,
 ) -> Result<Value, FilterAction> {
-    let compaction_id = format!("compact_{}", ctx.id_generator.generate(ctx.time_source));
     let resp_id = format!("resp_{}", ctx.id_generator.generate(ctx.time_source));
     let created_at = i64::try_from(ctx.time_source.now().as_secs()).unwrap_or(i64::MAX);
-    let model = req.model.as_deref().unwrap_or(&filter.config.default_model);
-    let compaction_item = build_compaction_item(&compaction_id, summary, &filter.config.summary_prefix);
-    let compacted_messages = Value::Array(vec![compaction_item]);
+
+    let output = match summary {
+        Some(summary) => {
+            let compaction_id = format!("compact_{}", ctx.id_generator.generate(ctx.time_source));
+            Value::Array(vec![build_compaction_item(
+                &compaction_id,
+                &summary.content,
+                &filter.config.summary_prefix,
+            )])
+        },
+        None => Value::Array(messages.to_vec()),
+    };
+    let usage = build_compaction_usage(messages, summary, &filter.config.tiktoken_encoding);
     let response_object = serde_json::json!({
         "id": resp_id,
-        "object": "response",
-        "status": "completed",
-        "model": model,
+        "object": "response.compaction",
         "created_at": created_at,
-        "previous_response_id": req.response_id,
-        "output": compacted_messages,
+        "output": output,
+        "usage": usage,
     });
 
     let record = ResponseRecord {
         id: resp_id,
         tenant_id: tenant_id.to_owned(),
         created_at,
-        model: model.to_owned(),
+        model: req.model.clone(),
         response_object: response_object.clone(),
-        input: compacted_messages.clone(),
-        messages: compacted_messages,
+        input: output.clone(),
+        messages: output,
     };
     store.upsert_response(&record).await.map_err(|e| {
         warn!(error = %e, "failed to persist explicit compaction response");
@@ -684,6 +705,63 @@ async fn build_and_persist_compaction(
     Ok(response_object)
 }
 
+/// Build a `ResponseUsage` object for the compaction pass.
+///
+/// Prefers the token counts the summarization callout itself reported,
+/// mapping the Chat Completions `usage` to the Responses shape. When the
+/// backend omits usage (or on a fail-open pass-through), falls back to a
+/// tiktoken estimate of the source conversation and produced summary.
+fn build_compaction_usage(messages: &[Value], summary: Option<&Summarization>, tiktoken_encoding: &str) -> Value {
+    if let Some(usage) = summary.and_then(|s| s.usage.as_ref()) {
+        return map_chat_usage(usage);
+    }
+    let conversation_text = build_conversation_text(messages);
+    let input_tokens = get_token_count(&conversation_text, tiktoken_encoding).unwrap_or(0);
+    let output_tokens = summary
+        .and_then(|s| get_token_count(&s.content, tiktoken_encoding))
+        .unwrap_or(0);
+    build_usage(input_tokens, 0, output_tokens, 0)
+}
+
+/// Map a Chat Completions `usage` object to the Responses `ResponseUsage` shape.
+fn map_chat_usage(usage: &Value) -> Value {
+    let field = |key: &str| usage.get(key).and_then(Value::as_u64).unwrap_or(0);
+    let input_tokens = field("prompt_tokens");
+    let output_tokens = field("completion_tokens");
+    let cached_tokens = usage
+        .get("prompt_tokens_details")
+        .and_then(|d| d.get("cached_tokens"))
+        .and_then(Value::as_u64)
+        .unwrap_or(0);
+    let reasoning_tokens = usage
+        .get("completion_tokens_details")
+        .and_then(|d| d.get("reasoning_tokens"))
+        .and_then(Value::as_u64)
+        .unwrap_or(0);
+    let total = usage
+        .get("total_tokens")
+        .and_then(Value::as_u64)
+        .unwrap_or_else(|| input_tokens.saturating_add(output_tokens));
+    serde_json::json!({
+        "input_tokens": input_tokens,
+        "input_tokens_details": {"cached_tokens": cached_tokens, "cache_write_tokens": 0},
+        "output_tokens": output_tokens,
+        "output_tokens_details": {"reasoning_tokens": reasoning_tokens},
+        "total_tokens": total,
+    })
+}
+
+/// Assemble a `ResponseUsage` object from raw token counts.
+fn build_usage(input_tokens: u64, cached_tokens: u64, output_tokens: u64, reasoning_tokens: u64) -> Value {
+    serde_json::json!({
+        "input_tokens": input_tokens,
+        "input_tokens_details": {"cached_tokens": cached_tokens, "cache_write_tokens": 0},
+        "output_tokens": output_tokens,
+        "output_tokens_details": {"reasoning_tokens": reasoning_tokens},
+        "total_tokens": input_tokens + output_tokens,
+    })
+}
+
 /// Build a `FilterAction::Reject` for an explicit compact error.
 fn reject_compact(status: u16, code: &str, message: &str) -> FilterAction {
     FilterAction::Reject(responses_error_rejection(status, code, message, false))
@@ -816,22 +894,27 @@ fn build_summarization_request(conversation_text: &str, instructions: Option<&st
     }
 }
 
-/// Parse the Chat Completions response and extract the summary text.
+/// Parse the Chat Completions response, extracting the summary text and
+/// the callout's own token usage.
 ///
-/// Expected shape: `{"choices": [{"message": {"content": "..."}}]}`
-fn parse_summarization_response(body: &[u8]) -> Result<String, String> {
-    match serde_json::from_slice::<Value>(body) {
-        Ok(body) => body
-            .get("choices")
-            .and_then(Value::as_array)
-            .and_then(|choices| choices.first())
-            .and_then(|choice| choice.get("message"))
-            .and_then(|msg| msg.get("content"))
-            .and_then(Value::as_str)
-            .map(ToOwned::to_owned)
-            .ok_or_else(|| "Chat Completions response missing choices[0].message.content".to_owned()),
-        Err(err) => Err(format!("failed to parse Chat Completions response JSON: {err}")),
-    }
+/// Expected shape:
+/// `{"choices": [{"message": {"content": "..."}}], "usage": {...}}`
+fn parse_summarization_response(body: &[u8]) -> Result<Summarization, String> {
+    let body: Value =
+        serde_json::from_slice(body).map_err(|err| format!("failed to parse Chat Completions response JSON: {err}"))?;
+    let content = body
+        .get("choices")
+        .and_then(Value::as_array)
+        .and_then(|choices| choices.first())
+        .and_then(|choice| choice.get("message"))
+        .and_then(|msg| msg.get("content"))
+        .and_then(Value::as_str)
+        .map(ToOwned::to_owned)
+        .ok_or_else(|| "Chat Completions response missing choices[0].message.content".to_owned())?;
+    Ok(Summarization {
+        content,
+        usage: body.get("usage").cloned(),
+    })
 }
 
 /// Build the compaction output item.
@@ -881,42 +964,6 @@ fn replace_messages(state: &mut ResponsesState, compaction_item: Value) {
     state.messages = new_messages;
 }
 
-/// Persist a hidden compaction response to the store so that it can
-/// be referenced via `previous_response_id` in future requests.
-///
-/// Best-effort: a store failure is logged but does not block the
-/// request — the main response's store filter will still persist
-/// the compacted messages as part of the regular response record.
-#[expect(clippy::too_many_arguments, reason = "all fields are needed for the record")]
-async fn persist_compaction_response(
-    store: &dyn crate::store::ResponseStore,
-    response_id: &str,
-    model: &str,
-    tenant_id: &str,
-    created_at: i64,
-    persisted_messages: Vec<Value>,
-) {
-    let persisted = Value::Array(persisted_messages);
-    let record = ResponseRecord {
-        id: response_id.to_owned(),
-        tenant_id: tenant_id.to_owned(),
-        created_at,
-        model: model.to_owned(),
-        response_object: serde_json::json!({
-            "id": response_id,
-            "object": "response",
-            "status": "completed",
-            "model": model,
-            "created_at": created_at,
-        }),
-        input: persisted.clone(),
-        messages: persisted,
-    };
-    if let Err(e) = store.upsert_response(&record).await {
-        warn!(error = %e, id = %response_id, "failed to persist compaction response");
-    }
-}
-
 /// Build a text representation of instructions and tool definitions for token counting.
 ///
 /// Returns an empty string when neither field is present. The result is
diff --git a/apis/src/openai/responses/compact/tests.rs b/apis/src/openai/responses/compact/tests.rs
index a537a8e6bb..3d919298a4 100644
--- a/apis/src/openai/responses/compact/tests.rs
+++ b/apis/src/openai/responses/compact/tests.rs
@@ -274,8 +274,20 @@ fn parse_valid_chat_completion_response() {
         }]
     });
     let body = serde_json::to_vec(&response).unwrap();
-    let result = parse_summarization_response(&body);
-    assert_eq!(result.unwrap(), "Here is the summary.");
+    let result = parse_summarization_response(&body).unwrap();
+    assert_eq!(result.content, "Here is the summary.");
+    assert!(result.usage.is_none(), "no usage reported by the callout");
+}
+
+#[test]
+fn parse_response_captures_usage() {
+    let response = json!({
+        "choices": [{"message": {"role": "assistant", "content": "Summary."}}],
+        "usage": {"prompt_tokens": 50, "completion_tokens": 10, "total_tokens": 60}
+    });
+    let body = serde_json::to_vec(&response).unwrap();
+    let result = parse_summarization_response(&body).unwrap();
+    assert_eq!(result.usage.unwrap()["total_tokens"], 60);
 }
 
 #[test]
@@ -298,6 +310,79 @@ fn parse_response_empty_choices_returns_error() {
     assert!(parse_summarization_response(&body).is_err());
 }
 
+// =============================================================================
+// usage mapping tests
+// =============================================================================
+
+#[test]
+fn map_chat_usage_maps_all_fields() {
+    let usage = json!({
+        "prompt_tokens": 50,
+        "completion_tokens": 10,
+        "total_tokens": 60,
+        "prompt_tokens_details": {"cached_tokens": 8},
+        "completion_tokens_details": {"reasoning_tokens": 4}
+    });
+    let mapped = map_chat_usage(&usage);
+    assert_eq!(mapped["input_tokens"], 50);
+    assert_eq!(mapped["output_tokens"], 10);
+    assert_eq!(mapped["total_tokens"], 60);
+    assert_eq!(mapped["input_tokens_details"]["cached_tokens"], 8);
+    assert_eq!(mapped["input_tokens_details"]["cache_write_tokens"], 0);
+    assert_eq!(mapped["output_tokens_details"]["reasoning_tokens"], 4);
+}
+
+#[test]
+fn map_chat_usage_defaults_missing_details_to_zero() {
+    let usage = json!({"prompt_tokens": 7, "completion_tokens": 3, "total_tokens": 10});
+    let mapped = map_chat_usage(&usage);
+    assert_eq!(mapped["input_tokens_details"]["cached_tokens"], 0);
+    assert_eq!(mapped["output_tokens_details"]["reasoning_tokens"], 0);
+}
+
+#[test]
+fn map_chat_usage_derives_total_when_absent() {
+    let usage = json!({"prompt_tokens": 12, "completion_tokens": 5});
+    let mapped = map_chat_usage(&usage);
+    assert_eq!(mapped["total_tokens"], 17, "total falls back to input + output");
+}
+
+#[test]
+fn build_compaction_usage_prefers_callout_usage() {
+    let summary = Summarization {
+        content: "short".to_owned(),
+        usage: Some(json!({"prompt_tokens": 100, "completion_tokens": 20, "total_tokens": 120})),
+    };
+    let messages = vec![json!({"role": "user", "content": "a much longer conversation body"})];
+    let usage = build_compaction_usage(&messages, Some(&summary), "cl100k_base");
+    // Reported usage wins over any tiktoken estimate of the message/summary text.
+    assert_eq!(usage["input_tokens"], 100);
+    assert_eq!(usage["output_tokens"], 20);
+    assert_eq!(usage["total_tokens"], 120);
+}
+
+#[test]
+fn build_compaction_usage_falls_back_to_tiktoken_when_usage_absent() {
+    let summary = Summarization {
+        content: "a produced summary".to_owned(),
+        usage: None,
+    };
+    let messages = vec![json!({"role": "user", "content": "the source conversation text"})];
+    let usage = build_compaction_usage(&messages, Some(&summary), "cl100k_base");
+    assert!(
+        usage["input_tokens"].as_u64().unwrap() > 0,
+        "estimates source conversation"
+    );
+    assert!(
+        usage["output_tokens"].as_u64().unwrap() > 0,
+        "estimates produced summary"
+    );
+    assert_eq!(
+        usage["total_tokens"].as_u64().unwrap(),
+        usage["input_tokens"].as_u64().unwrap() + usage["output_tokens"].as_u64().unwrap()
+    );
+}
+
 // =============================================================================
 // build_conversation_text tests
 // =============================================================================
@@ -744,30 +829,49 @@ fn tiktoken_fallback_includes_instructions_and_tools_in_count() {
 // =============================================================================
 
 #[test]
-fn parse_compact_request_body_valid() {
+fn parse_compact_request_body_with_previous_response_id() {
     let body = Some(Bytes::from(
         serde_json::to_vec(&json!({
-            "response_id": "resp_abc",
             "model": "gpt-4o",
+            "previous_response_id": "resp_abc",
             "instructions": "Be concise"
         }))
         .unwrap(),
     ));
     let req = parse_compact_request_body(&body).unwrap();
-    assert_eq!(req.response_id, "resp_abc");
-    assert_eq!(req.model.as_deref(), Some("gpt-4o"));
+    assert_eq!(req.model, "gpt-4o");
+    assert_eq!(req.previous_response_id.as_deref(), Some("resp_abc"));
+    assert!(req.input.is_empty());
     assert_eq!(req.instructions.as_deref(), Some("Be concise"));
 }
 
 #[test]
-fn parse_compact_request_body_minimal() {
+fn parse_compact_request_body_with_string_input() {
     let body = Some(Bytes::from(
-        serde_json::to_vec(&json!({"response_id": "resp_xyz"})).unwrap(),
+        serde_json::to_vec(&json!({"model": "gpt-4o", "input": "Summarize this"})).unwrap(),
+    ));
+    let req = parse_compact_request_body(&body).unwrap();
+    assert_eq!(req.model, "gpt-4o");
+    assert!(req.previous_response_id.is_none());
+    assert_eq!(req.input.len(), 1, "string input coerces to one user message");
+    assert_eq!(req.input[0]["role"], "user");
+    assert_eq!(req.input[0]["content"], "Summarize this");
+}
+
+#[test]
+fn parse_compact_request_body_with_array_input() {
+    let body = Some(Bytes::from(
+        serde_json::to_vec(&json!({
+            "model": "gpt-4o",
+            "input": [
+                {"role": "user", "content": "Hello"},
+                {"role": "assistant", "content": "Hi"}
+            ]
+        }))
+        .unwrap(),
     ));
     let req = parse_compact_request_body(&body).unwrap();
-    assert_eq!(req.response_id, "resp_xyz");
-    assert!(req.model.is_none());
-    assert!(req.instructions.is_none());
+    assert_eq!(req.input.len(), 2);
 }
 
 #[test]
@@ -782,67 +886,48 @@ fn parse_compact_request_body_invalid_json() {
 }
 
 #[test]
-fn parse_compact_request_body_missing_response_id() {
-    let body = Some(Bytes::from(serde_json::to_vec(&json!({"model": "gpt-4o"})).unwrap()));
+fn parse_compact_request_body_missing_model() {
+    // `model` is required by the contract even when content is present.
+    let body = Some(Bytes::from(serde_json::to_vec(&json!({"input": "hello"})).unwrap()));
     assert!(parse_compact_request_body(&body).is_err());
 }
 
 #[test]
-fn parse_compact_request_body_empty_response_id() {
+fn parse_compact_request_body_empty_model() {
     let body = Some(Bytes::from(
-        serde_json::to_vec(&json!({"response_id": "", "model": "gpt-4o"})).unwrap(),
+        serde_json::to_vec(&json!({"model": "", "input": "hello"})).unwrap(),
     ));
     assert!(parse_compact_request_body(&body).is_err());
 }
 
+#[test]
+fn parse_compact_request_body_missing_content() {
+    // `model` alone, with neither `input` nor `previous_response_id`.
+    let body = Some(Bytes::from(serde_json::to_vec(&json!({"model": "gpt-4o"})).unwrap()));
+    assert!(parse_compact_request_body(&body).is_err());
+}
+
 // =============================================================================
-// extract_stored_messages
+// stored_message_array
 // =============================================================================
 
 #[test]
-fn extract_stored_messages_returns_messages() {
-    let record = ResponseRecord {
-        id: "resp_1".to_owned(),
-        tenant_id: "default".to_owned(),
-        created_at: 0,
-        model: "gpt-4o".to_owned(),
-        response_object: json!({}),
-        input: json!([]),
-        messages: json!([
-            {"role": "user", "content": "Hello"},
-            {"role": "assistant", "content": "Hi"}
-        ]),
-    };
-    let msgs = extract_stored_messages(record).unwrap();
-    assert_eq!(msgs.len(), 2);
+fn stored_message_array_returns_messages() {
+    let messages = json!([
+        {"role": "user", "content": "Hello"},
+        {"role": "assistant", "content": "Hi"}
+    ]);
+    assert_eq!(stored_message_array(messages).len(), 2);
 }
 
 #[test]
-fn extract_stored_messages_empty_array() {
-    let record = ResponseRecord {
-        id: "resp_1".to_owned(),
-        tenant_id: "default".to_owned(),
-        created_at: 0,
-        model: "gpt-4o".to_owned(),
-        response_object: json!({}),
-        input: json!([]),
-        messages: json!([]),
-    };
-    assert!(extract_stored_messages(record).is_err());
+fn stored_message_array_empty_array() {
+    assert!(stored_message_array(json!([])).is_empty());
 }
 
 #[test]
-fn extract_stored_messages_not_array() {
-    let record = ResponseRecord {
-        id: "resp_1".to_owned(),
-        tenant_id: "default".to_owned(),
-        created_at: 0,
-        model: "gpt-4o".to_owned(),
-        response_object: json!({}),
-        input: json!([]),
-        messages: json!("not an array"),
-    };
-    assert!(extract_stored_messages(record).is_err());
+fn stored_message_array_not_array() {
+    assert!(stored_message_array(json!("not an array")).is_empty());
 }
 
 // =============================================================================
diff --git a/docs/filters/openai_responses_compact.md b/docs/filters/openai_responses_compact.md
index 70d95e19bd..3577af485f 100644
--- a/docs/filters/openai_responses_compact.md
+++ b/docs/filters/openai_responses_compact.md
@@ -13,7 +13,7 @@ Compaction applies in two scenarios:
 
 - **Rehydrated history** — stored history loaded via `previous_response_id` or `conversation`. Only the stored history is summarized; the current turn is preserved.
 
-- **Explicit compact** — `POST /v1/responses/compact` with a `response_id`. Loads stored messages, summarizes them, and persists a new compacted response.
+- **Explicit compact** — `POST /v1/responses/compact` with a required `model` and an inline `input` conversation and/or a `previous_response_id`. Loads any stored history, appends the inline input, summarizes the combined conversation, and returns a `response.compaction` object (with `output` and `usage`) per the OpenAI contract.
 
 Direct input requests (full conversation in `input` with no stored history) skip reactive compaction because `state.input == state.messages` — there is no separable "current turn" to preserve after summarization. Requests without rehydrated history are released without compaction.
 
diff --git a/tests/integration/tests/suite/examples/compact.rs b/tests/integration/tests/suite/examples/compact.rs
index ee38a06d26..95f99a4a6b 100644
--- a/tests/integration/tests/suite/examples/compact.rs
+++ b/tests/integration/tests/suite/examples/compact.rs
@@ -18,6 +18,7 @@ use praxis_test_utils::{
     Backend, TempSqlite, bind_unique_port, example_config_path, free_port, http_send, json_post, parse_body,
     parse_status, patch_yaml, start_proxy,
 };
+use sqlx::Row as _;
 
 // -----------------------------------------------------------------------------
 // Constants
@@ -28,11 +29,20 @@ use praxis_test_utils::{
 const FIRST_RESPONSE_JSON: &str = r#"{"id":"resp_compact","created_at":1000,"model":"gpt-4.1","object":"response","status":"completed","input":"Explain TCP vs UDP","output":[{"type":"message","content":[{"type":"output_text","text":"TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability."}]}]}"#;
 
 /// Chat Completions response used for the summarization callout.
-const CHAT_COMPLETIONS_RESPONSE: &str = r#"{"id":"chatcmpl-1","object":"chat.completion","choices":[{"index":0,"message":{"role":"assistant","content":"Summary of the conversation."},"finish_reason":"stop"}],"usage":{"prompt_tokens":50,"completion_tokens":10,"total_tokens":60}}"#;
+///
+/// Carries the full `CompletionUsage` shape — including
+/// `prompt_tokens_details.cached_tokens` and
+/// `completion_tokens_details.reasoning_tokens` — so tests can verify those
+/// counts are threaded into the compaction `ResponseUsage`.
+const CHAT_COMPLETIONS_RESPONSE: &str = r#"{"id":"chatcmpl-1","object":"chat.completion","choices":[{"index":0,"message":{"role":"assistant","content":"Summary of the conversation."},"finish_reason":"stop"}],"usage":{"prompt_tokens":50,"completion_tokens":10,"total_tokens":60,"prompt_tokens_details":{"cached_tokens":5},"completion_tokens_details":{"reasoning_tokens":3}}}"#;
 
 /// Responses API response returned for the main inference call.
 const INFERENCE_RESPONSE: &str = r#"{"id":"resp_inf","created_at":2000,"model":"gpt-4.1","object":"response","status":"completed","output":[{"type":"message","content":[{"type":"output_text","text":"QUIC is faster."}]}]}"#;
 
+/// Summarization callout response that omits the `usage` object, forcing the
+/// compaction usage to fall back to a tiktoken estimate.
+const CHAT_COMPLETIONS_NO_USAGE: &str = r#"{"id":"chatcmpl-2","object":"chat.completion","choices":[{"index":0,"message":{"role":"assistant","content":"Summary of the conversation."},"finish_reason":"stop"}]}"#;
+
 // -----------------------------------------------------------------------------
 // Helpers
 // -----------------------------------------------------------------------------
@@ -123,6 +133,41 @@ fn handle_sequenced_request(
     drop(stream.write_all(response.as_bytes()));
 }
 
+/// Assert a `usage` object carries every field the OpenAI `ResponseUsage`
+/// schema marks as required (including the nested detail objects).
+fn assert_response_usage_contract(usage: &serde_json::Value) {
+    assert!(usage["input_tokens"].is_u64(), "usage.input_tokens required: {usage}");
+    assert!(usage["output_tokens"].is_u64(), "usage.output_tokens required: {usage}");
+    assert!(usage["total_tokens"].is_u64(), "usage.total_tokens required: {usage}");
+    let input_details = &usage["input_tokens_details"];
+    assert!(
+        input_details["cached_tokens"].is_u64(),
+        "input_tokens_details.cached_tokens required: {usage}"
+    );
+    assert!(
+        input_details["cache_write_tokens"].is_u64(),
+        "input_tokens_details.cache_write_tokens required: {usage}"
+    );
+    assert!(
+        usage["output_tokens_details"]["reasoning_tokens"].is_u64(),
+        "output_tokens_details.reasoning_tokens required: {usage}"
+    );
+}
+
+/// Assert a compaction `output` item carries every field the OpenAI
+/// `CompactionBody` schema marks as required.
+fn assert_compaction_item_contract(item: &serde_json::Value) {
+    assert_eq!(item["type"], "compaction", "compaction item type: {item}");
+    assert!(
+        item["id"].as_str().is_some_and(|id| !id.is_empty()),
+        "compaction item requires a non-empty id: {item}"
+    );
+    assert!(
+        item["encrypted_content"].as_str().is_some_and(|c| !c.is_empty()),
+        "compaction item requires encrypted_content: {item}"
+    );
+}
+
 // -----------------------------------------------------------------------------
 // Tests
 // -----------------------------------------------------------------------------
@@ -389,25 +434,331 @@ async fn compact_explicit_endpoint() {
         proxy2.addr(),
         &json_post(
             "/v1/responses/compact",
-            r#"{"response_id":"resp_compact","model":"gpt-4.1"}"#,
+            r#"{"model":"gpt-4.1","previous_response_id":"resp_compact"}"#,
         ),
     );
     assert_eq!(parse_status(&raw2), 200, "explicit compact should return 200");
 
     let body = parse_body(&raw2);
     let resp: serde_json::Value = serde_json::from_str(&body).expect("response should be valid JSON");
-    assert_eq!(resp["object"], "response", "should be a response object");
-    assert_eq!(resp["status"], "completed");
     assert_eq!(
-        resp["previous_response_id"], "resp_compact",
-        "should reference the original response"
+        resp["object"], "response.compaction",
+        "should be a response.compaction object per the OpenAI contract"
+    );
+    // CompactResource required fields: id, object, output, created_at, usage.
+    assert!(resp["id"].is_string(), "compaction response must have an id");
+    assert!(
+        resp["created_at"].is_number(),
+        "compaction response must have created_at"
     );
     let output = resp["output"].as_array().expect("output should be an array");
     assert_eq!(output.len(), 1, "output should have one compaction item");
-    assert_eq!(output[0]["type"], "compaction");
+    assert_compaction_item_contract(&output[0]);
+
+    let usage = &resp["usage"];
+    assert_response_usage_contract(usage);
+    // Usage is threaded through from the summarization callout, not re-estimated.
+    // CHAT_COMPLETIONS_RESPONSE reports prompt=50, completion=10, total=60 with
+    // cached_tokens=5 and reasoning_tokens=3 in its detail objects.
+    assert_eq!(usage["input_tokens"], 50, "input_tokens must reflect callout usage");
+    assert_eq!(usage["output_tokens"], 10, "output_tokens must reflect callout usage");
+    assert_eq!(usage["total_tokens"], 60, "total_tokens must reflect callout usage");
+    assert_eq!(
+        usage["input_tokens_details"]["cached_tokens"], 5,
+        "cached_tokens must be threaded from the callout's prompt_tokens_details"
+    );
+    assert_eq!(
+        usage["output_tokens_details"]["reasoning_tokens"], 3,
+        "reasoning_tokens must be threaded from the callout's completion_tokens_details"
+    );
+    drop(proxy2);
+
+    // The explicit endpoint persists the compaction record. Read it back and
+    // confirm the stored row matches the returned response and is itself
+    // contract-shaped.
+    let returned_id = resp["id"].as_str().expect("response id should be a string");
+    let pool = sqlx::SqlitePool::connect(db.url())
+        .await
+        .expect("should connect to test database");
+    let row = sqlx::query("SELECT tenant_id, model, response_object, messages FROM openai_responses WHERE id = ?")
+        .bind(returned_id)
+        .fetch_one(&pool)
+        .await
+        .expect("compaction record should be persisted");
+    pool.close().await;
+
+    let tenant_id: String = row.get("tenant_id");
+    let model: String = row.get("model");
+    assert_eq!(tenant_id, "default", "compaction record should use the default tenant");
+    assert_eq!(model, "gpt-4.1", "compaction record should persist the request model");
+
+    let stored_object: serde_json::Value =
+        serde_json::from_str(&row.get::<String, _>("response_object")).expect("response_object should be valid JSON");
+    assert_eq!(
+        stored_object["object"], "response.compaction",
+        "stored response_object should be a response.compaction"
+    );
+    assert_eq!(
+        stored_object["id"], returned_id,
+        "stored id should match the returned id"
+    );
+    assert_response_usage_contract(&stored_object["usage"]);
+
+    let stored_messages: serde_json::Value =
+        serde_json::from_str(&row.get::<String, _>("messages")).expect("messages should be valid JSON");
+    let items = stored_messages.as_array().expect("messages should be an array");
+    assert_eq!(
+        items.len(),
+        1,
+        "persisted messages should hold the single compaction item"
+    );
+    assert_compaction_item_contract(&items[0]);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_explicit_endpoint_inline_input() {
+    // A contract-conforming `{model, input}` request (no previous_response_id)
+    // must be accepted and compact the inline conversation directly.
+    let backend = Backend::fixed(CHAT_COMPLETIONS_RESPONSE)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+    let config = load_compact_config(&yaml, "sqlite::memory:", proxy_port, backend.port());
+    let proxy = start_proxy(&config);
+
+    let raw = http_send(
+        proxy.addr(),
+        &json_post(
+            "/v1/responses/compact",
+            r#"{"model":"gpt-4.1","input":[{"role":"user","content":"Explain TCP vs UDP"},{"role":"assistant","content":"TCP is reliable, UDP is not."}]}"#,
+        ),
+    );
+    assert_eq!(
+        parse_status(&raw),
+        200,
+        "standard {{model, input}} compact request should be accepted"
+    );
+
+    let body = parse_body(&raw);
+    let resp: serde_json::Value = serde_json::from_str(&body).expect("response should be valid JSON");
+    assert_eq!(resp["object"], "response.compaction");
+    let output = resp["output"].as_array().expect("output should be an array");
+    assert_eq!(output.len(), 1, "output should have one compaction item");
+    assert_compaction_item_contract(&output[0]);
+    assert_response_usage_contract(&resp["usage"]);
+    drop(proxy);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_explicit_endpoint_unknown_previous_response_id() {
+    // Referencing a response that was never stored must fail before any
+    // summarization callout, with a not-found error. In the recommended
+    // pipeline `rehydrate` runs ahead of compact and rejects the unknown
+    // `previous_response_id` with a 400 "not found", so that is what the
+    // client sees end-to-end (compact's own 404 arm is only reachable when
+    // rehydrate is absent from the chain).
+    let backend = Backend::fixed(CHAT_COMPLETIONS_RESPONSE)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+    let config = load_compact_config(&yaml, "sqlite::memory:", proxy_port, backend.port());
+    let proxy = start_proxy(&config);
+
+    let raw = http_send(
+        proxy.addr(),
+        &json_post(
+            "/v1/responses/compact",
+            r#"{"model":"gpt-4.1","previous_response_id":"resp_never_stored"}"#,
+        ),
+    );
+
+    assert_eq!(
+        parse_status(&raw),
+        400,
+        "unknown previous_response_id should return 400"
+    );
     assert!(
-        output[0].get("encrypted_content").is_some(),
-        "compaction item should have encrypted_content"
+        raw.contains("not found"),
+        "response should explain the id was not found: {raw}"
+    );
+    drop(proxy);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_explicit_endpoint_fail_closed_on_callout_error() {
+    // Phase 1: store a response to reference.
+    let backend1 = Backend::fixed(FIRST_RESPONSE_JSON)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let db = TempSqlite::new("compact_fail_closed");
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+
+    let config1 = load_compact_config(&yaml, db.url(), proxy_port, backend1.port());
+    let proxy1 = start_proxy(&config1);
+    let raw1 = http_send(
+        proxy1.addr(),
+        &json_post("/v1/responses", r#"{"model":"gpt-4.1","input":"Explain TCP vs UDP"}"#),
     );
+    assert_eq!(parse_status(&raw1), 200, "first request should store response");
+    drop(backend1);
+    drop(proxy1);
+
+    // Phase 2: the summarization callout fails. The example config uses the
+    // default on_failure=closed, so the request must be rejected with 502.
+    let backend2 = Backend::status(500, r#"{"error":{"message":"backend exploded"}}"#)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend2.port());
+    let proxy2 = start_proxy(&config2);
+
+    let raw = http_send(
+        proxy2.addr(),
+        &json_post(
+            "/v1/responses/compact",
+            r#"{"model":"gpt-4.1","previous_response_id":"resp_compact"}"#,
+        ),
+    );
+    assert_eq!(
+        parse_status(&raw),
+        502,
+        "failed callout under fail-closed should return 502"
+    );
+    assert!(
+        raw.contains("summarization callout rejected"),
+        "response should explain the callout was rejected: {raw}"
+    );
+    drop(proxy2);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_explicit_endpoint_estimates_usage_when_callout_omits_it() {
+    // Phase 1: store a response to reference.
+    let backend1 = Backend::fixed(FIRST_RESPONSE_JSON)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let db = TempSqlite::new("compact_usage_fallback");
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+
+    let config1 = load_compact_config(&yaml, db.url(), proxy_port, backend1.port());
+    let proxy1 = start_proxy(&config1);
+    let raw1 = http_send(
+        proxy1.addr(),
+        &json_post("/v1/responses", r#"{"model":"gpt-4.1","input":"Explain TCP vs UDP"}"#),
+    );
+    assert_eq!(parse_status(&raw1), 200, "first request should store response");
+    drop(backend1);
+    drop(proxy1);
+
+    // Phase 2: the callout succeeds but omits `usage`; compaction usage must
+    // fall back to a tiktoken estimate of the conversation and summary.
+    let backend2 = Backend::fixed(CHAT_COMPLETIONS_NO_USAGE)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend2.port());
+    let proxy2 = start_proxy(&config2);
+
+    let raw = http_send(
+        proxy2.addr(),
+        &json_post(
+            "/v1/responses/compact",
+            r#"{"model":"gpt-4.1","previous_response_id":"resp_compact"}"#,
+        ),
+    );
+    assert_eq!(parse_status(&raw), 200, "explicit compact should return 200");
+
+    let resp: serde_json::Value = serde_json::from_str(&parse_body(&raw)).expect("response should be valid JSON");
+    let usage = &resp["usage"];
+    // Even on the estimated path the emitted usage must satisfy the contract.
+    assert_response_usage_contract(usage);
+    let input_tokens = usage["input_tokens"].as_u64().expect("input_tokens should be a number");
+    let output_tokens = usage["output_tokens"]
+        .as_u64()
+        .expect("output_tokens should be a number");
+    // The stored conversation is large, so the estimate must be non-trivial and
+    // must NOT be the callout values (there were none to thread through).
+    assert!(
+        input_tokens > 100,
+        "estimated input_tokens should reflect the long conversation"
+    );
+    assert!(output_tokens > 0, "estimated output_tokens should reflect the summary");
+    assert_eq!(
+        usage["total_tokens"].as_u64().unwrap(),
+        input_tokens + output_tokens,
+        "total should be the sum of estimated input and output tokens"
+    );
+    drop(proxy2);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_reactive_with_store_false_does_not_persist() {
+    // Phase 1: store the first turn.
+    let backend1 = Backend::fixed(FIRST_RESPONSE_JSON)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let db = TempSqlite::new("compact_store_false");
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+
+    let config1 = load_compact_config(&yaml, db.url(), proxy_port, backend1.port());
+    let proxy1 = start_proxy(&config1);
+    let raw1 = http_send(
+        proxy1.addr(),
+        &json_post("/v1/responses", r#"{"model":"gpt-4.1","input":"Explain TCP vs UDP"}"#),
+    );
+    assert_eq!(parse_status(&raw1), 200, "first request should store response");
+    drop(backend1);
+    drop(proxy1);
+
+    // Phase 2: a reactive compaction turn with store:false. The callout
+    // summarizes, the compacted request is forwarded to inference, but nothing
+    // from this turn — neither the inference response nor an orphan compaction
+    // row — may be persisted.
+    let (backend_port, _captured) = start_sequenced_backend(CHAT_COMPLETIONS_RESPONSE, INFERENCE_RESPONSE);
+    let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend_port);
+    let proxy2 = start_proxy(&config2);
+
+    let raw2 = http_send(
+        proxy2.addr(),
+        &json_post(
+            "/v1/responses",
+            r#"{"model":"gpt-4.1","input":"Compare with QUIC","previous_response_id":"resp_compact","context_management":[{"type":"compaction","compact_threshold":1000}],"store":false}"#,
+        ),
+    );
+    assert_eq!(parse_status(&raw2), 200, "compaction turn should succeed");
     drop(proxy2);
+
+    // The database must still contain exactly the first turn's response.
+    let pool = sqlx::SqlitePool::connect(db.url())
+        .await
+        .expect("should connect to test database");
+    let total: i64 = sqlx::query("SELECT COUNT(*) AS n FROM openai_responses")
+        .fetch_one(&pool)
+        .await
+        .expect("count query should run")
+        .get("n");
+    let inference_persisted: i64 = sqlx::query("SELECT COUNT(*) AS n FROM openai_responses WHERE id = ?")
+        .bind("resp_inf")
+        .fetch_one(&pool)
+        .await
+        .expect("lookup query should run")
+        .get("n");
+    pool.close().await;
+
+    assert_eq!(
+        total, 1,
+        "store:false turn must not add rows (only the first turn persists)"
+    );
+    assert_eq!(
+        inference_persisted, 0,
+        "the store:false inference response must not be persisted"
+    );
 }

From d6ce970c79b4848be6624723b85f44c8dbb37276 Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Wed, 9 Sep 2026 11:34:50 +0200
Subject: [PATCH 03/10] fix(compact): reject invalid compaction config.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs      | 45 ++++++++++++++-----
 .../tests/suite/examples/compact.rs           | 21 +++++----
 2 files changed, 44 insertions(+), 22 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index a11c241ad3..d097911148 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -384,6 +384,9 @@ impl HttpFilter for CompactFilter {
             return Ok(FilterAction::Release);
         }
         let streaming = is_streaming(ctx);
+        if let Some(action) = reject_invalid_compaction_config(ctx, streaming) {
+            return Ok(action);
+        }
         if !ensure_compactable_state(ctx) {
             return Ok(FilterAction::Release);
         }
@@ -411,6 +414,25 @@ fn ensure_compactable_state(ctx: &HttpFilterContext<'_>) -> bool {
     is_compactable(ctx.extensions.get::<ResponsesState>())
 }
 
+/// Reject the request when a compaction config is present but invalid.
+///
+/// Runs for every Responses request so an invalid `compact_threshold` is
+/// rejected even when reactive compaction is ultimately skipped (e.g. direct
+/// input without a rehydrated history to separate from the current turn).
+/// Returns `None` when there is no config, or the config is valid.
+fn reject_invalid_compaction_config(ctx: &HttpFilterContext<'_>, streaming: bool) -> Option<FilterAction> {
+    let state = ctx.extensions.get::<ResponsesState>()?;
+    match extract_compaction_config(&state.context_management) {
+        Ok(_) => None,
+        Err(msg) => Some(FilterAction::Reject(responses_error_rejection(
+            400,
+            "invalid_request_error",
+            &msg,
+            streaming,
+        ))),
+    }
+}
+
 /// Check whether the given state qualifies for reactive compaction.
 ///
 /// Returns `true` only when rehydrated history is present. Direct
@@ -419,11 +441,13 @@ fn ensure_compactable_state(ctx: &HttpFilterContext<'_>) -> bool {
 /// turn" to preserve after summarization. Use the explicit
 /// `POST /v1/responses/compact` endpoint for non-rehydrated history.
 ///
-/// This gate is the single decision point for direct-input handling:
-/// `should_compact` and `replace_messages` retain direct-input branches
-/// (and unit tests for them) documenting the lower-level contract, but
-/// those branches are unreachable through the filter while this returns
-/// `false` for non-rehydrated state.
+/// This gate is the single decision point for direct-input handling.
+/// `should_compact` still evaluates the threshold for direct input (and
+/// unit tests exercise that lower-level contract directly), but the
+/// summarization it would trigger is unreachable through the filter while
+/// this returns `false` for non-rehydrated state. Threshold *validation*
+/// is separate: `reject_invalid_compaction_config` runs before this gate,
+/// so an invalid `compact_threshold` is rejected for direct input too.
 fn is_compactable(state: Option<&ResponsesState>) -> bool {
     let Some(state) = state else {
         return false;
@@ -453,12 +477,11 @@ fn should_compact(
     let Some(params) = extract_compaction_config(&state.context_management)? else {
         return Ok(None);
     };
-    let history = if state.history_rehydrated {
-        let end = state.messages.len().saturating_sub(state.input.len());
-        state.messages.get(..end).unwrap_or(&state.messages)
-    } else {
-        &state.messages
-    };
+    // Summarize the full conversation, including the current turn, so the
+    // summarizer has complete context. The current turn is not lost from the
+    // rehydrated history: `replace_messages` preserves it verbatim after the
+    // compaction item via a tail split, so it appears exactly once.
+    let history = &state.messages;
 
     if let Some(token_count) = previous_usage_total(state) {
         if !exceeds_threshold(token_count, &params) {
diff --git a/tests/integration/tests/suite/examples/compact.rs b/tests/integration/tests/suite/examples/compact.rs
index 591a6ba448..2e31cba063 100644
--- a/tests/integration/tests/suite/examples/compact.rs
+++ b/tests/integration/tests/suite/examples/compact.rs
@@ -579,17 +579,16 @@ fn compact_direct_input_skips_reactive_compaction() {
     let config = load_compact_config(&yaml, "sqlite::memory:", proxy_port, backend.port());
     let proxy = start_proxy(&config);
 
-    // Send a full conversation in `input` with context_management but
-    // no previous_response_id. Reactive compaction is skipped because
-    // state.input == state.messages — there is no separable "current
-    // turn" to preserve after summarization.
-    let raw = http_send(
-        proxy.addr(),
-        &json_post(
-            "/v1/responses",
-            r#"{"model":"gpt-4.1","input":[{"role":"user","content":"Explain TCP vs UDP in detail"},{"role":"assistant","content":"TCP is a connection-oriented protocol."},{"role":"user","content":"Compare with QUIC"}],"context_management":[{"type":"compaction","compact_threshold":50}]}"#,
-        ),
-    );
+    // Send a full conversation in `input` with a valid compaction config
+    // whose token count exceeds the threshold, but no previous_response_id.
+    // Reactive compaction is still skipped because state.input ==
+    // state.messages — there is no separable "current turn" to preserve
+    // after summarization — so the request passes through untouched.
+    let padding = "context padding ".repeat(700);
+    let body = format!(
+        r#"{{"model":"gpt-4.1","input":[{{"role":"user","content":"Explain TCP vs UDP in detail"}},{{"role":"assistant","content":"TCP is a connection-oriented protocol. {padding}"}},{{"role":"user","content":"Compare with QUIC"}}],"context_management":[{{"type":"compaction","compact_threshold":1000}}]}}"#
+    );
+    let raw = http_send(proxy.addr(), &json_post("/v1/responses", &body));
     assert_eq!(
         parse_status(&raw),
         200,

From bdce1c1b590b9983d6de8b86995c4be140a07d7f Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Wed, 9 Sep 2026 11:49:16 +0200
Subject: [PATCH 04/10] fix(compact): cosmetics.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs         | 12 ++++++------
 docs/filters/openai_responses_compact.md         |  6 +++---
 .../integration/tests/suite/examples/compact.rs  | 16 ++++++++--------
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index d097911148..d9da5fe3a9 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -16,7 +16,7 @@
 //!
 //! Compaction only applies to **multi-turn requests** where
 //! `openai_responses_rehydrate` has loaded stored conversation history
-//! — i.e. requests that include `previous_response_id` or
+//! - i.e. requests that include `previous_response_id` or
 //! `conversation`. Single-turn requests (no stored history, even with
 //! `context_management` set) are released without compaction because
 //! there is no prior history to summarize.
@@ -116,15 +116,15 @@ struct Summarization {
 ///
 /// Compaction applies in two scenarios:
 ///
-/// - **Rehydrated history** — stored history loaded via `previous_response_id` or `conversation`. Only the stored
+/// - **Rehydrated history** - stored history loaded via `previous_response_id` or `conversation`. Only the stored
 ///   history is summarized; the current turn is preserved.
 ///
-/// - **Explicit compact** — `POST /v1/responses/compact` with a required `model` and an inline `input` conversation
+/// - **Explicit compact** - `POST /v1/responses/compact` with a required `model` and an inline `input` conversation
 ///   and/or a `previous_response_id`. Loads any stored history, appends the inline input, summarizes the combined
 ///   conversation, and returns a `response.compaction` object (with `output` and `usage`) per the OpenAI contract.
 ///
 /// Direct input requests (full conversation in `input` with no stored history) skip reactive compaction because
-/// `state.input == state.messages` — there is no separable "current turn" to preserve after summarization.
+/// `state.input == state.messages` - there is no separable "current turn" to preserve after summarization.
 /// Requests without rehydrated history are released without compaction.
 ///
 /// Praxis runs `StreamBuffer` body hooks before header-phase request
@@ -437,7 +437,7 @@ fn reject_invalid_compaction_config(ctx: &HttpFilterContext<'_>, streaming: bool
 ///
 /// Returns `true` only when rehydrated history is present. Direct
 /// input requests (no `previous_response_id`) are skipped because
-/// `state.input == state.messages` — there is no separable "current
+/// `state.input == state.messages` - there is no separable "current
 /// turn" to preserve after summarization. Use the explicit
 /// `POST /v1/responses/compact` endpoint for non-rehydrated history.
 ///
@@ -461,7 +461,7 @@ fn is_compactable(state: Option<&ResponsesState>) -> bool {
 /// unknown, or the token count is below the threshold.
 ///
 /// When `previous_usage` is available from the rehydrated response,
-/// its `total_tokens` is used directly — avoiding the cost of BPE
+/// its `total_tokens` is used directly - avoiding the cost of BPE
 /// tokenization. Falls back to tiktoken estimation otherwise. The
 /// fallback estimate includes instructions and tool definitions in
 /// addition to conversation messages, since all three contribute to
diff --git a/docs/filters/openai_responses_compact.md b/docs/filters/openai_responses_compact.md
index 3577af485f..7bddf9a682 100644
--- a/docs/filters/openai_responses_compact.md
+++ b/docs/filters/openai_responses_compact.md
@@ -11,11 +11,11 @@ Summarizes conversation history when the token count exceeds a configured thresh
 
 Compaction applies in two scenarios:
 
-- **Rehydrated history** — stored history loaded via `previous_response_id` or `conversation`. Only the stored history is summarized; the current turn is preserved.
+- **Rehydrated history** - stored history loaded via `previous_response_id` or `conversation`. Only the stored history is summarized; the current turn is preserved.
 
-- **Explicit compact** — `POST /v1/responses/compact` with a required `model` and an inline `input` conversation and/or a `previous_response_id`. Loads any stored history, appends the inline input, summarizes the combined conversation, and returns a `response.compaction` object (with `output` and `usage`) per the OpenAI contract.
+- **Explicit compact** - `POST /v1/responses/compact` with a required `model` and an inline `input` conversation and/or a `previous_response_id`. Loads any stored history, appends the inline input, summarizes the combined conversation, and returns a `response.compaction` object (with `output` and `usage`) per the OpenAI contract.
 
-Direct input requests (full conversation in `input` with no stored history) skip reactive compaction because `state.input == state.messages` — there is no separable "current turn" to preserve after summarization. Requests without rehydrated history are released without compaction.
+Direct input requests (full conversation in `input` with no stored history) skip reactive compaction because `state.input == state.messages` - there is no separable "current turn" to preserve after summarization. Requests without rehydrated history are released without compaction.
 
 Praxis runs `StreamBuffer` body hooks before header-phase request filters. This filter therefore requires `allow_pre_security_callout: true` and should only be used behind an outer authentication and authorization boundary.
 
diff --git a/tests/integration/tests/suite/examples/compact.rs b/tests/integration/tests/suite/examples/compact.rs
index 2e31cba063..2ad338694a 100644
--- a/tests/integration/tests/suite/examples/compact.rs
+++ b/tests/integration/tests/suite/examples/compact.rs
@@ -26,15 +26,15 @@ use super::openai_file_resolve::{start_file_url_stub, start_files_api_stub};
 // Constants
 // -----------------------------------------------------------------------------
 
-/// Backend response for the first turn — stored by response_store.
+/// Backend response for the first turn - stored by response_store.
 /// The output text is long enough to exceed a 1000 token compact_threshold.
 const FIRST_RESPONSE_JSON: &str = r#"{"id":"resp_compact","created_at":1000,"model":"gpt-4.1","object":"response","status":"completed","input":"Explain TCP vs UDP","output":[{"type":"message","content":[{"type":"output_text","text":"TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability. TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It establishes a connection through a three-way handshake before transmitting data. UDP is a connectionless protocol that sends data without establishing a connection first. TCP guarantees delivery through acknowledgments and retransmissions while UDP does not. TCP is used for applications requiring reliability like web browsing and email while UDP is used for real-time applications like video streaming and gaming where speed matters more than reliability."}]}]}"#;
 
 /// Chat Completions response used for the summarization callout.
 ///
-/// Carries the full `CompletionUsage` shape — including
+/// Carries the full `CompletionUsage` shape - including
 /// `prompt_tokens_details.cached_tokens` and
-/// `completion_tokens_details.reasoning_tokens` — so tests can verify those
+/// `completion_tokens_details.reasoning_tokens` - so tests can verify those
 /// counts are threaded into the compaction `ResponseUsage`.
 const CHAT_COMPLETIONS_RESPONSE: &str = r#"{"id":"chatcmpl-1","object":"chat.completion","choices":[{"index":0,"message":{"role":"assistant","content":"Summary of the conversation."},"finish_reason":"stop"}],"usage":{"prompt_tokens":50,"completion_tokens":10,"total_tokens":60,"prompt_tokens_details":{"cached_tokens":5},"completion_tokens_details":{"reasoning_tokens":3}}}"#;
 
@@ -305,7 +305,7 @@ async fn compact_verifies_summarization_call_and_compacted_state() {
     drop(backend1);
     drop(proxy1);
 
-    // Second turn: sequenced backend — first call is summarization, second is inference.
+    // Second turn: sequenced backend - first call is summarization, second is inference.
     let (backend_port, captured_inference_body) =
         start_sequenced_backend(CHAT_COMPLETIONS_RESPONSE, INFERENCE_RESPONSE);
 
@@ -582,8 +582,8 @@ fn compact_direct_input_skips_reactive_compaction() {
     // Send a full conversation in `input` with a valid compaction config
     // whose token count exceeds the threshold, but no previous_response_id.
     // Reactive compaction is still skipped because state.input ==
-    // state.messages — there is no separable "current turn" to preserve
-    // after summarization — so the request passes through untouched.
+    // state.messages - there is no separable "current turn" to preserve
+    // after summarization - so the request passes through untouched.
     let padding = "context padding ".repeat(700);
     let body = format!(
         r#"{{"model":"gpt-4.1","input":[{{"role":"user","content":"Explain TCP vs UDP in detail"}},{{"role":"assistant","content":"TCP is a connection-oriented protocol. {padding}"}},{{"role":"user","content":"Compare with QUIC"}}],"context_management":[{{"type":"compaction","compact_threshold":1000}}]}}"#
@@ -915,8 +915,8 @@ async fn compact_reactive_with_store_false_does_not_persist() {
 
     // Phase 2: a reactive compaction turn with store:false. The callout
     // summarizes, the compacted request is forwarded to inference, but nothing
-    // from this turn — neither the inference response nor an orphan compaction
-    // row — may be persisted.
+    // from this turn - neither the inference response nor an orphan compaction
+    // row - may be persisted.
     let (backend_port, _captured) = start_sequenced_backend(CHAT_COMPLETIONS_RESPONSE, INFERENCE_RESPONSE);
     let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend_port);
     let proxy2 = start_proxy(&config2);

From 95925a49e222a6db4ebf3afb7f49d998a6e0fc56 Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Wed, 9 Sep 2026 12:16:17 +0200
Subject: [PATCH 05/10] fix(compact): avoid accidental doc list from hyphen in
 module doc

Rephrase the module-level Scope doc so a line no longer begins with "- ",
which clippy's doc_lazy_continuation lint treated as a markdown list item
with unindented continuations. No behavior change.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index d9da5fe3a9..2d038fad79 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -15,8 +15,8 @@
 //! # Scope
 //!
 //! Compaction only applies to **multi-turn requests** where
-//! `openai_responses_rehydrate` has loaded stored conversation history
-//! - i.e. requests that include `previous_response_id` or
+//! `openai_responses_rehydrate` has loaded stored conversation history,
+//! i.e. requests that include `previous_response_id` or
 //! `conversation`. Single-turn requests (no stored history, even with
 //! `context_management` set) are released without compaction because
 //! there is no prior history to summarize.

From 174248341aeea617a1019781df17755cd92dbf95 Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Wed, 9 Sep 2026 17:16:56 +0200
Subject: [PATCH 06/10] fix(compact): address review nits on usage overflow and
 config parsing

- build_usage: use saturating_add for total_tokens to avoid overflow
- extract_compaction_config: reject present-but-non-array
  context_management with an error; keep absent/null as no-op.
  Extract per-entry parsing into parse_compaction_entry helper to
  stay within the line limit.
- build_and_persist_compaction: document the fail-open pass-through
  arm (usage.output_tokens is 0; caller detects the no-op via the
  absent compaction item).

Adds unit tests for null-as-absent and non-array-error cases.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs   | 70 ++++++++++++----------
 apis/src/openai/responses/compact/tests.rs | 19 ++++++
 2 files changed, 57 insertions(+), 32 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index 9dbe4b981c..1b54541486 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -688,6 +688,11 @@ async fn build_and_persist_compaction(
                 &filter.config.summary_prefix,
             )])
         },
+        // Fail-open pass-through: the summarization callout failed but
+        // `on_failure: open` is configured, so instead of erroring we return the
+        // conversation uncompacted. `usage.output_tokens` is 0 because no summary
+        // was produced (see `build_compaction_usage`); the caller can detect the
+        // no-op by the absence of a `compaction` item in `output`.
         None => Value::Array(messages.to_vec()),
     };
     let usage = build_compaction_usage(messages, summary, &filter.config.tiktoken_encoding);
@@ -768,7 +773,7 @@ fn build_usage(input_tokens: u64, cached_tokens: u64, output_tokens: u64, reason
         "input_tokens_details": {"cached_tokens": cached_tokens, "cache_write_tokens": 0},
         "output_tokens": output_tokens,
         "output_tokens_details": {"reasoning_tokens": reasoning_tokens},
-        "total_tokens": input_tokens + output_tokens,
+        "total_tokens": input_tokens.saturating_add(output_tokens),
     })
 }
 
@@ -783,47 +788,48 @@ fn reject_compact(status: u16, code: &str, message: &str) -> FilterAction {
 /// `[{"type": "compaction", "compact_threshold": 50000}]`
 ///
 /// Returns:
-/// - `Ok(None)` if no compaction entry is present.
+/// - `Ok(None)` if `context_management` is absent, `null`, or an array with no compaction entry.
 /// - `Ok(Some(params))` if a valid compaction entry is present.
-/// - `Err(msg)` if a compaction entry is present but has an invalid `compact_threshold` or `compaction_model`.
+/// - `Err(msg)` if `context_management` is present but not an array, or a compaction entry has an invalid
+///   `compact_threshold` or `compaction_model`.
 fn extract_compaction_config(context_management: &Option<Value>) -> Result<Option<CompactionParams>, String> {
-    let Some(array) = context_management.as_ref().and_then(Value::as_array) else {
+    // Absent or explicit null: OpenAI treats both as "no context management".
+    let Some(value) = context_management.as_ref().filter(|v| !v.is_null()) else {
         return Ok(None);
     };
-
+    let Some(array) = value.as_array() else {
+        return Err("context_management must be an array".to_owned());
+    };
     for entry in array {
-        let Some(entry_type) = entry.get("type").and_then(|v| v.as_str()) else {
-            continue;
-        };
-        if entry_type != "compaction" {
-            continue;
-        }
-
-        let err_msg = "compact_threshold must be an integer of at least 1000";
-        let raw_threshold = entry.get("compact_threshold").ok_or_else(|| err_msg.to_owned())?;
-        let compact_threshold = raw_threshold.as_u64().ok_or_else(|| err_msg.to_owned())?;
-        if compact_threshold < MIN_COMPACT_THRESHOLD {
-            return Err(err_msg.to_owned());
+        if entry.get("type").and_then(Value::as_str) == Some("compaction") {
+            return parse_compaction_entry(entry).map(Some);
         }
-
-        let compaction_model = if let Some(m) = entry.get("compaction_model") {
-            let model_str = m
-                .as_str()
-                .ok_or_else(|| "compaction_model must be a string".to_owned())?;
-            Some(model_str.to_owned())
-        } else {
-            None
-        };
-
-        return Ok(Some(CompactionParams {
-            compact_threshold,
-            compaction_model,
-        }));
     }
-
     Ok(None)
 }
 
+/// Parse a single `{"type": "compaction", ...}` entry into [`CompactionParams`].
+fn parse_compaction_entry(entry: &Value) -> Result<CompactionParams, String> {
+    let err_msg = "compact_threshold must be an integer of at least 1000";
+    let raw_threshold = entry.get("compact_threshold").ok_or_else(|| err_msg.to_owned())?;
+    let compact_threshold = raw_threshold.as_u64().ok_or_else(|| err_msg.to_owned())?;
+    if compact_threshold < MIN_COMPACT_THRESHOLD {
+        return Err(err_msg.to_owned());
+    }
+    let compaction_model = match entry.get("compaction_model") {
+        Some(m) => Some(
+            m.as_str()
+                .ok_or_else(|| "compaction_model must be a string".to_owned())?
+                .to_owned(),
+        ),
+        None => None,
+    };
+    Ok(CompactionParams {
+        compact_threshold,
+        compaction_model,
+    })
+}
+
 /// Resolve the tiktoken singleton for the given encoding name.
 fn resolve_tiktoken(encoding: &str) -> Option<&'static tiktoken_rs::CoreBPE> {
     match encoding {
diff --git a/apis/src/openai/responses/compact/tests.rs b/apis/src/openai/responses/compact/tests.rs
index 8988bc7119..806a319616 100644
--- a/apis/src/openai/responses/compact/tests.rs
+++ b/apis/src/openai/responses/compact/tests.rs
@@ -162,6 +162,25 @@ fn extract_compaction_config_none() {
     assert!(extract_compaction_config(&None).unwrap().is_none());
 }
 
+#[test]
+fn extract_compaction_config_null_is_treated_as_absent() {
+    let cm = Some(json!(null));
+    assert!(
+        extract_compaction_config(&cm).unwrap().is_none(),
+        "explicit null context_management should behave like an omitted field"
+    );
+}
+
+#[test]
+fn extract_compaction_config_non_array_returns_error() {
+    let cm = Some(json!({"type": "compaction", "compact_threshold": 1000}));
+    let err = extract_compaction_config(&cm).unwrap_err();
+    assert!(
+        err.contains("context_management must be an array"),
+        "a present but non-array context_management must be rejected, got: {err}"
+    );
+}
+
 #[test]
 fn extract_compaction_config_empty_array() {
     let cm = Some(json!([]));

From 92d2c481d74af3c2867df45784260eff64cb6f2a Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Thu, 10 Sep 2026 09:31:13 +0200
Subject: [PATCH 07/10] docs(compact): update module scope to cover the
 explicit endpoint

The module-level # Scope section only described reactive multi-turn
compaction and omitted POST /v1/responses/compact, which summarizes any
previously stored response regardless of rehydration. Bring it in line
with the CompactFilter struct doc, which already describes both the
reactive and explicit scenarios.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index 1b54541486..eeced6c5ee 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -14,12 +14,20 @@
 //!
 //! # Scope
 //!
-//! Compaction only applies to **multi-turn requests** where
-//! `openai_responses_rehydrate` has loaded stored conversation history,
-//! i.e. requests that include `previous_response_id` or
-//! `conversation`. Single-turn requests (no stored history, even with
-//! `context_management` set) are released without compaction because
-//! there is no prior history to summarize.
+//! Compaction applies in two scenarios:
+//!
+//! - **Reactive** — multi-turn requests where
+//!   `openai_responses_rehydrate` has loaded stored conversation
+//!   history, i.e. requests that include `previous_response_id` or
+//!   `conversation`. Single-turn requests (no stored history, even
+//!   with `context_management` set) are released without compaction
+//!   because there is no prior history to summarize.
+//! - **Explicit** — `POST /v1/responses/compact`, which summarizes any
+//!   previously stored response (plus optional inline `input`)
+//!   regardless of rehydration, returning a `response.compaction`
+//!   object.
+//!
+//! See [`CompactFilter`] for the full description of both scenarios.
 //!
 //! Praxis runs `StreamBuffer` body hooks before header-phase request
 //! filters. Configuration therefore requires an explicit

From e02ffc476b131c5a78bc0e218bd4750bbe5107b3 Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Thu, 10 Sep 2026 10:36:52 +0200
Subject: [PATCH 08/10] style(compact): reflow module scope doc to comment
 width

CI's nightly rustfmt reflows doc-comment prose to the configured
comment_width (120); the hand-wrapped bullets from the previous commit
tripped `fmt --all --check`. Reflow to match.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index eeced6c5ee..010c03e0f2 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -16,16 +16,11 @@
 //!
 //! Compaction applies in two scenarios:
 //!
-//! - **Reactive** — multi-turn requests where
-//!   `openai_responses_rehydrate` has loaded stored conversation
-//!   history, i.e. requests that include `previous_response_id` or
-//!   `conversation`. Single-turn requests (no stored history, even
-//!   with `context_management` set) are released without compaction
-//!   because there is no prior history to summarize.
-//! - **Explicit** — `POST /v1/responses/compact`, which summarizes any
-//!   previously stored response (plus optional inline `input`)
-//!   regardless of rehydration, returning a `response.compaction`
-//!   object.
+//! - **Reactive** — multi-turn requests where `openai_responses_rehydrate` has loaded stored conversation history, i.e.
+//!   requests that include `previous_response_id` or `conversation`. Single-turn requests (no stored history, even with
+//!   `context_management` set) are released without compaction because there is no prior history to summarize.
+//! - **Explicit** — `POST /v1/responses/compact`, which summarizes any previously stored response (plus optional inline
+//!   `input`) regardless of rehydration, returning a `response.compaction` object.
 //!
 //! See [`CompactFilter`] for the full description of both scenarios.
 //!

From 4704dc76fc01a45ed7ed8e73e3ea61514489897f Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Thu, 10 Sep 2026 13:40:09 +0200
Subject: [PATCH 09/10] refactor(compact): small refactor around compaction
 items and their persistence.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs      | 154 +++++++++++-------
 .../tests/suite/examples/compact.rs           |  96 +++++++++++
 2 files changed, 191 insertions(+), 59 deletions(-)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index 010c03e0f2..78090b5272 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -331,9 +331,20 @@ impl CompactFilter {
         let req = parse_compact_request_body(body)?;
         let (store, tenant_id) = resolve_store_and_tenant(ctx)?;
         let messages = collect_compact_messages(&*store, &tenant_id, &req).await?;
-        let summary = self.summarize_messages(&req, &messages).await?;
-        let response_object =
-            build_and_persist_compaction(self, ctx, &*store, &tenant_id, &req, &messages, summary.as_ref()).await?;
+        let writer = CompactionWriter {
+            filter: self,
+            ctx,
+            store: &*store,
+            tenant_id: &tenant_id,
+            req: &req,
+            messages: &messages,
+        };
+        let response_object = if let Some(summary) = self.summarize_messages(&req, &messages).await? {
+            writer.persist_compacted(&summary).await?
+        } else {
+            warn!("fail-open compaction: summarization callout failed; persisting uncompacted no-op");
+            writer.persist_uncompacted().await?
+        };
         let body_bytes = serde_json::to_vec(&response_object).unwrap_or_default();
         Ok(FilterAction::Reject(
             praxis_filter::Rejection::status(200)
@@ -664,63 +675,88 @@ fn stored_message_array(messages: Value) -> Vec<Value> {
     }
 }
 
-/// Build and persist the compaction result for an explicit compact request.
-#[expect(
-    clippy::too_many_arguments,
-    clippy::too_many_lines,
-    reason = "all parameters are needed to build and persist the record"
-)]
-async fn build_and_persist_compaction(
-    filter: &CompactFilter,
-    ctx: &HttpFilterContext<'_>,
-    store: &dyn crate::store::ResponseStore,
-    tenant_id: &str,
-    req: &ExplicitCompactRequest,
-    messages: &[Value],
-    summary: Option<&Summarization>,
-) -> Result<Value, FilterAction> {
-    let resp_id = format!("resp_{}", ctx.id_generator.generate(ctx.time_source));
-    let created_at = i64::try_from(ctx.time_source.now().as_secs()).unwrap_or(i64::MAX);
-
-    let output = match summary {
-        Some(summary) => {
-            let compaction_id = format!("compact_{}", ctx.id_generator.generate(ctx.time_source));
-            Value::Array(vec![build_compaction_item(
-                &compaction_id,
-                &summary.content,
-                &filter.config.summary_prefix,
-            )])
-        },
-        // Fail-open pass-through: the summarization callout failed but
-        // `on_failure: open` is configured, so instead of erroring we return the
-        // conversation uncompacted. `usage.output_tokens` is 0 because no summary
-        // was produced (see `build_compaction_usage`); the caller can detect the
-        // no-op by the absence of a `compaction` item in `output`.
-        None => Value::Array(messages.to_vec()),
-    };
-    let usage = build_compaction_usage(messages, summary, &filter.config.tiktoken_encoding);
-    let response_object = serde_json::json!({
-        "id": resp_id,
-        "object": "response.compaction",
-        "created_at": created_at,
-        "output": output,
-        "usage": usage,
-    });
+/// Borrows everything needed to build and persist an explicit compaction
+/// result, so the persist paths read as methods rather than long argument lists.
+struct CompactionWriter<'a> {
+    /// Filter config (summary prefix, tiktoken encoding).
+    filter: &'a CompactFilter,
+    /// Request context, used for id and timestamp generation.
+    ctx: &'a HttpFilterContext<'a>,
+    /// Response store the compaction record is persisted to.
+    store: &'a dyn crate::store::ResponseStore,
+    /// Tenant the record is scoped to.
+    tenant_id: &'a str,
+    /// The parsed explicit compact request (supplies the response model).
+    req: &'a ExplicitCompactRequest,
+    /// The conversation being compacted.
+    messages: &'a [Value],
+}
 
-    let record = ResponseRecord {
-        id: resp_id,
-        tenant_id: tenant_id.to_owned(),
-        created_at,
-        model: req.model.clone(),
-        response_object: response_object.clone(),
-        input: output.clone(),
-        messages: output,
-    };
-    store.upsert_response(&record).await.map_err(|e| {
-        warn!(error = %e, "failed to persist explicit compaction response");
-        reject_compact(500, "server_error", "failed to persist compaction response")
-    })?;
-    Ok(response_object)
+impl CompactionWriter<'_> {
+    /// Persist the compaction result for a successful summarization. The
+    /// response `output` and the persisted history are the same single
+    /// compaction item.
+    async fn persist_compacted(&self, summary: &Summarization) -> Result<Value, FilterAction> {
+        let compaction_id = format!("compact_{}", self.ctx.id_generator.generate(self.ctx.time_source));
+        let item = Value::Array(vec![build_compaction_item(
+            &compaction_id,
+            &summary.content,
+            &self.filter.config.summary_prefix,
+        )]);
+        let usage = build_compaction_usage(self.messages, Some(summary), &self.filter.config.tiktoken_encoding);
+        self.persist_response(item.clone(), item, usage).await
+    }
+
+    /// Persist an uncompacted no-op when the summarization callout fails under
+    /// `on_failure: open`.
+    ///
+    /// The response `output` is an empty array: there is no summary, so no
+    /// `compaction` item is emitted, and its absence is the caller's no-op
+    /// signal. Returning the raw `{role, content}` messages instead would
+    /// violate the Responses output schema (items require `type`/`id`/`status`).
+    /// The intact conversation is still persisted as the record's history so a
+    /// follow-up request referencing this response id rehydrates it in full.
+    async fn persist_uncompacted(&self) -> Result<Value, FilterAction> {
+        let usage = build_compaction_usage(self.messages, None, &self.filter.config.tiktoken_encoding);
+        self.persist_response(Value::Array(Vec::new()), Value::Array(self.messages.to_vec()), usage)
+            .await
+    }
+
+    /// Assemble the `response.compaction` object, persist the record, and return
+    /// the object. `output` is the API-facing output array; `stored_messages` is
+    /// the history persisted for rehydration continuity (the two differ on
+    /// fail-open).
+    async fn persist_response(
+        &self,
+        output: Value,
+        stored_messages: Value,
+        usage: Value,
+    ) -> Result<Value, FilterAction> {
+        let resp_id = format!("resp_{}", self.ctx.id_generator.generate(self.ctx.time_source));
+        let created_at = i64::try_from(self.ctx.time_source.now().as_secs()).unwrap_or(i64::MAX);
+        let response_object = serde_json::json!({
+            "id": resp_id,
+            "object": "response.compaction",
+            "created_at": created_at,
+            "output": output,
+            "usage": usage,
+        });
+
+        let record = ResponseRecord {
+            id: resp_id,
+            tenant_id: self.tenant_id.to_owned(),
+            created_at,
+            model: self.req.model.clone(),
+            response_object: response_object.clone(),
+            input: stored_messages.clone(),
+            messages: stored_messages,
+        };
+        self.store.upsert_response(&record).await.map_err(|e| {
+            warn!(error = %e, "failed to persist explicit compaction response");
+            reject_compact(500, "server_error", "failed to persist compaction response")
+        })?;
+        Ok(response_object)
+    }
 }
 
 /// Build a `ResponseUsage` object for the compaction pass.
diff --git a/tests/integration/tests/suite/examples/compact.rs b/tests/integration/tests/suite/examples/compact.rs
index 2ad338694a..11305ba634 100644
--- a/tests/integration/tests/suite/examples/compact.rs
+++ b/tests/integration/tests/suite/examples/compact.rs
@@ -831,6 +831,102 @@ async fn compact_explicit_endpoint_fail_closed_on_callout_error() {
     drop(proxy2);
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_explicit_endpoint_fail_open_returns_schema_valid_empty_output() {
+    // Phase 1: store a response to reference.
+    let backend1 = Backend::fixed(FIRST_RESPONSE_JSON)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let db = TempSqlite::new("compact_fail_open");
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+    // Opt the compact filter into fail-open so a failed callout yields a no-op
+    // compaction response rather than a 502.
+    let yaml = yaml.replace(
+        "        default_model: llama3.2:1b\n",
+        "        default_model: llama3.2:1b\n        on_failure: open\n",
+    );
+
+    let config1 = load_compact_config(&yaml, db.url(), proxy_port, backend1.port());
+    let proxy1 = start_proxy(&config1);
+    let raw1 = http_send(
+        proxy1.addr(),
+        &json_post("/v1/responses", r#"{"model":"gpt-4.1","input":"Explain TCP vs UDP"}"#),
+    );
+    assert_eq!(parse_status(&raw1), 200, "first request should store response");
+    drop(backend1);
+    drop(proxy1);
+
+    // Phase 2: the summarization callout fails. Under on_failure=open the
+    // endpoint must return a schema-valid response.compaction with an EMPTY
+    // output array (no compaction item = the no-op signal), never the raw
+    // `{role, content}` messages, which would lack the required output-item
+    // fields and break typed OpenAI clients.
+    let backend2 = Backend::status(500, r#"{"error":{"message":"backend exploded"}}"#)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend2.port());
+    let proxy2 = start_proxy(&config2);
+
+    let raw = http_send(
+        proxy2.addr(),
+        &json_post(
+            "/v1/responses/compact",
+            r#"{"model":"gpt-4.1","previous_response_id":"resp_compact"}"#,
+        ),
+    );
+    assert_eq!(
+        parse_status(&raw),
+        200,
+        "failed callout under fail-open should return 200: {raw}"
+    );
+
+    let body = parse_body(&raw);
+    let resp: serde_json::Value = serde_json::from_str(&body).expect("response should be valid JSON");
+    assert_eq!(
+        resp["object"], "response.compaction",
+        "fail-open response should still be a response.compaction object"
+    );
+    let output = resp["output"].as_array().expect("output should be an array");
+    assert!(
+        output.is_empty(),
+        "fail-open output must be empty (no compaction item), got: {output:?}"
+    );
+    // No summary was produced, so no output tokens were generated.
+    assert_response_usage_contract(&resp["usage"]);
+    assert_eq!(
+        resp["usage"]["output_tokens"], 0,
+        "fail-open usage.output_tokens must be 0 (no summary produced)"
+    );
+    drop(proxy2);
+
+    // The intact conversation must still be persisted so a follow-up request
+    // using this response id rehydrates the full history rather than nothing.
+    let returned_id = resp["id"].as_str().expect("response id should be a string");
+    let pool = sqlx::SqlitePool::connect(db.url())
+        .await
+        .expect("should connect to test database");
+    let row = sqlx::query("SELECT messages FROM openai_responses WHERE id = ?")
+        .bind(returned_id)
+        .fetch_one(&pool)
+        .await
+        .expect("compaction record should be persisted");
+    pool.close().await;
+
+    let stored_messages: serde_json::Value =
+        serde_json::from_str(&row.get::<String, _>("messages")).expect("messages should be valid JSON");
+    let items = stored_messages.as_array().expect("messages should be an array");
+    assert!(
+        !items.is_empty(),
+        "fail-open must persist the intact conversation, not an empty history"
+    );
+    assert!(
+        items.iter().all(|m| m["type"] != "compaction"),
+        "fail-open persisted history must not contain a compaction item: {items:?}"
+    );
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn compact_explicit_endpoint_estimates_usage_when_callout_omits_it() {
     // Phase 1: store a response to reference.

From 8eeb6485373f3f9b78c73f603d3c87dd2e61ee4b Mon Sep 17 00:00:00 2001
From: Alexander Cristurean <acristur@redhat.com>
Date: Thu, 10 Sep 2026 15:40:33 +0200
Subject: [PATCH 10/10] fix: add completed status to persisted responses.

Signed-off-by: Alexander Cristurean <acristur@redhat.com>
---
 apis/src/openai/responses/compact/mod.rs      |  1 +
 .../tests/suite/examples/compact.rs           | 75 +++++++++++++++++++
 2 files changed, 76 insertions(+)

diff --git a/apis/src/openai/responses/compact/mod.rs b/apis/src/openai/responses/compact/mod.rs
index 78090b5272..0bfc75297f 100644
--- a/apis/src/openai/responses/compact/mod.rs
+++ b/apis/src/openai/responses/compact/mod.rs
@@ -738,6 +738,7 @@ impl CompactionWriter<'_> {
             "id": resp_id,
             "object": "response.compaction",
             "created_at": created_at,
+            "status": "completed",
             "output": output,
             "usage": usage,
         });
diff --git a/tests/integration/tests/suite/examples/compact.rs b/tests/integration/tests/suite/examples/compact.rs
index 11305ba634..1b29c5b148 100644
--- a/tests/integration/tests/suite/examples/compact.rs
+++ b/tests/integration/tests/suite/examples/compact.rs
@@ -710,6 +710,81 @@ async fn compact_explicit_endpoint() {
     assert_compaction_item_contract(&items[0]);
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn compact_explicit_endpoint_response_is_valid_follow_up_target() {
+    // Regression: the compaction response must be usable as a
+    // `previous_response_id`. `rehydrate::validate_response_status` rejects any
+    // stored record whose `status` is not "completed" (missing status reads as
+    // 'unknown'), so the compaction object must persist `status: "completed"`.
+    // Otherwise the id we hand back cannot actually be continued from, breaking
+    // the follow-up continuity the endpoint advertises.
+
+    // Phase 1: store a response via normal inference.
+    let backend1 = Backend::fixed(FIRST_RESPONSE_JSON)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let proxy_port = free_port();
+    let db = TempSqlite::new("compact_follow_up");
+    let yaml = std::fs::read_to_string(example_config_path("openai/responses/compact.yaml"))
+        .expect("example config should exist");
+
+    let config1 = load_compact_config(&yaml, db.url(), proxy_port, backend1.port());
+    let proxy1 = start_proxy(&config1);
+    let raw1 = http_send(
+        proxy1.addr(),
+        &json_post("/v1/responses", r#"{"model":"gpt-4.1","input":"Explain TCP vs UDP"}"#),
+    );
+    assert_eq!(parse_status(&raw1), 200, "first request should store response");
+    drop(backend1);
+    drop(proxy1);
+
+    // Phase 2: explicitly compact the stored response and capture the returned id.
+    let backend2 = Backend::fixed(CHAT_COMPLETIONS_RESPONSE)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let config2 = load_compact_config(&yaml, db.url(), proxy_port, backend2.port());
+    let proxy2 = start_proxy(&config2);
+    let raw2 = http_send(
+        proxy2.addr(),
+        &json_post(
+            "/v1/responses/compact",
+            r#"{"model":"gpt-4.1","previous_response_id":"resp_compact"}"#,
+        ),
+    );
+    assert_eq!(parse_status(&raw2), 200, "explicit compact should return 200");
+    let compaction: serde_json::Value =
+        serde_json::from_str(&parse_body(&raw2)).expect("response should be valid JSON");
+    assert_eq!(
+        compaction["status"], "completed",
+        "compaction response must carry status 'completed' to be a valid follow-up target"
+    );
+    let compaction_id = compaction["id"]
+        .as_str()
+        .expect("compaction response should have an id")
+        .to_owned();
+    drop(backend2);
+    drop(proxy2);
+
+    // Phase 3: send a follow-up request referencing the compaction id. Rehydrate
+    // must accept the record (status == "completed") and continue from it. Before
+    // the status fix this failed with 400 "cannot continue from response with
+    // status 'unknown'".
+    let backend3 = Backend::fixed(INFERENCE_RESPONSE)
+        .header("content-type", "application/json")
+        .start_with_shutdown();
+    let config3 = load_compact_config(&yaml, db.url(), proxy_port, backend3.port());
+    let proxy3 = start_proxy(&config3);
+    let follow_up =
+        format!(r#"{{"model":"gpt-4.1","input":"Compare with QUIC","previous_response_id":"{compaction_id}"}}"#);
+    let raw3 = http_send(proxy3.addr(), &json_post("/v1/responses", &follow_up));
+    assert_eq!(
+        parse_status(&raw3),
+        200,
+        "follow-up referencing the compaction id should rehydrate and succeed, body: {raw3}"
+    );
+    drop(proxy3);
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn compact_explicit_endpoint_inline_input() {
     // A contract-conforming `{model, input}` request (no previous_response_id)