mirror of
https://github.com/openai/codex.git
synced 2026-09-06 15:29:32 +00:00
18cefba922
## Why Remote compaction currently sends a unary `POST /responses/compact` and waits for the full response before replacing history or emitting the completed `ContextCompaction` item. Unlike normal `/responses` streaming requests, this unary compact request had no timeout boundary. If the backend accepts the request and then stalls before returning a body, the existing request retry policy never sees a transport error, so the compact turn can remain stuck after the started item with no completion or actionable error. That matches the reported hang shape in issues such as #18363, where logs show `responses/compact` was posted but no corresponding compact completion followed. A bounded request timeout gives the existing retry policy a concrete timeout error to retry instead of letting the user sit indefinitely on automatic context compaction. ## What - Add a request timeout to legacy `/responses/compact` calls. - Size that timeout from the provider stream idle timeout with a conservative multiplier, so the default compact attempt gets 20 minutes rather than the 5 minute stream idle window. - Map API transport timeouts to a request timeout error instead of the child-process timeout message. ## Testing - Not run (per request; CI will cover).
105 lines
2.9 KiB
Rust
105 lines
2.9 KiB
Rust
use crate::auth::SharedAuthProvider;
|
|
use crate::common::CompactionInput;
|
|
use crate::endpoint::session::EndpointSession;
|
|
use crate::error::ApiError;
|
|
use crate::provider::Provider;
|
|
use codex_client::HttpTransport;
|
|
use codex_client::RequestTelemetry;
|
|
use codex_protocol::models::ResponseItem;
|
|
use http::HeaderMap;
|
|
use http::Method;
|
|
use serde::Deserialize;
|
|
use serde_json::to_value;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
|
|
pub struct CompactClient<T: HttpTransport> {
|
|
session: EndpointSession<T>,
|
|
}
|
|
|
|
impl<T: HttpTransport> CompactClient<T> {
|
|
pub fn new(transport: T, provider: Provider, auth: SharedAuthProvider) -> Self {
|
|
Self {
|
|
session: EndpointSession::new(transport, provider, auth),
|
|
}
|
|
}
|
|
|
|
pub fn with_telemetry(self, request: Option<Arc<dyn RequestTelemetry>>) -> Self {
|
|
Self {
|
|
session: self.session.with_request_telemetry(request),
|
|
}
|
|
}
|
|
|
|
fn path() -> &'static str {
|
|
"responses/compact"
|
|
}
|
|
|
|
pub async fn compact(
|
|
&self,
|
|
body: serde_json::Value,
|
|
extra_headers: HeaderMap,
|
|
request_timeout: Duration,
|
|
) -> Result<Vec<ResponseItem>, ApiError> {
|
|
let resp = self
|
|
.session
|
|
.execute_with(
|
|
Method::POST,
|
|
Self::path(),
|
|
extra_headers,
|
|
Some(body),
|
|
|req| {
|
|
req.timeout = Some(request_timeout);
|
|
},
|
|
)
|
|
.await?;
|
|
let parsed: CompactHistoryResponse =
|
|
serde_json::from_slice(&resp.body).map_err(|e| ApiError::Stream(e.to_string()))?;
|
|
Ok(parsed.output)
|
|
}
|
|
|
|
pub async fn compact_input(
|
|
&self,
|
|
input: &CompactionInput<'_>,
|
|
extra_headers: HeaderMap,
|
|
request_timeout: Duration,
|
|
) -> Result<Vec<ResponseItem>, ApiError> {
|
|
let body = to_value(input)
|
|
.map_err(|e| ApiError::Stream(format!("failed to encode compaction input: {e}")))?;
|
|
self.compact(body, extra_headers, request_timeout).await
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct CompactHistoryResponse {
|
|
output: Vec<ResponseItem>,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use async_trait::async_trait;
|
|
use codex_client::Request;
|
|
use codex_client::Response;
|
|
use codex_client::StreamResponse;
|
|
use codex_client::TransportError;
|
|
|
|
#[derive(Clone, Default)]
|
|
struct DummyTransport;
|
|
|
|
#[async_trait]
|
|
impl HttpTransport for DummyTransport {
|
|
async fn execute(&self, _req: Request) -> Result<Response, TransportError> {
|
|
Err(TransportError::Build("execute should not run".to_string()))
|
|
}
|
|
|
|
async fn stream(&self, _req: Request) -> Result<StreamResponse, TransportError> {
|
|
Err(TransportError::Build("stream should not run".to_string()))
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn path_is_responses_compact() {
|
|
assert_eq!(CompactClient::<DummyTransport>::path(), "responses/compact");
|
|
}
|
|
}
|