mirror of
https://github.com/openai/codex.git
synced 2026-04-28 10:21:06 +03:00
21c6d40a44
Adds a new feature `enable_request_compression` that will compress using zstd requests to the codex-backend. Currently only enabled for codex-backend so only enabled for openai providers when using chatgpt::auth even when the feature is enabled Added a new info log line too for evaluating the compression ratio and overhead off compressing before requesting. You can enable with `RUST_LOG=$RUST_LOG,codex_client::transport=info` ``` 2026-01-06T00:09:48.272113Z INFO codex_client::transport: Compressed request body with zstd pre_compression_bytes=28914 post_compression_bytes=11485 compression_duration_ms=0 ```
86 lines
2.5 KiB
Rust
86 lines
2.5 KiB
Rust
use crate::auth::AuthProvider;
|
|
use crate::auth::add_auth_headers;
|
|
use crate::common::ResponseStream;
|
|
use crate::error::ApiError;
|
|
use crate::provider::Provider;
|
|
use crate::telemetry::SseTelemetry;
|
|
use crate::telemetry::run_with_request_telemetry;
|
|
use codex_client::HttpTransport;
|
|
use codex_client::RequestCompression;
|
|
use codex_client::RequestTelemetry;
|
|
use codex_client::StreamResponse;
|
|
use http::HeaderMap;
|
|
use http::Method;
|
|
use serde_json::Value;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
|
|
pub(crate) struct StreamingClient<T: HttpTransport, A: AuthProvider> {
|
|
transport: T,
|
|
provider: Provider,
|
|
auth: A,
|
|
request_telemetry: Option<Arc<dyn RequestTelemetry>>,
|
|
sse_telemetry: Option<Arc<dyn SseTelemetry>>,
|
|
}
|
|
|
|
impl<T: HttpTransport, A: AuthProvider> StreamingClient<T, A> {
|
|
pub(crate) fn new(transport: T, provider: Provider, auth: A) -> Self {
|
|
Self {
|
|
transport,
|
|
provider,
|
|
auth,
|
|
request_telemetry: None,
|
|
sse_telemetry: None,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn with_telemetry(
|
|
mut self,
|
|
request: Option<Arc<dyn RequestTelemetry>>,
|
|
sse: Option<Arc<dyn SseTelemetry>>,
|
|
) -> Self {
|
|
self.request_telemetry = request;
|
|
self.sse_telemetry = sse;
|
|
self
|
|
}
|
|
|
|
pub(crate) fn provider(&self) -> &Provider {
|
|
&self.provider
|
|
}
|
|
|
|
pub(crate) async fn stream(
|
|
&self,
|
|
path: &str,
|
|
body: Value,
|
|
extra_headers: HeaderMap,
|
|
compression: RequestCompression,
|
|
spawner: fn(StreamResponse, Duration, Option<Arc<dyn SseTelemetry>>) -> ResponseStream,
|
|
) -> Result<ResponseStream, ApiError> {
|
|
let builder = || {
|
|
let mut req = self.provider.build_request(Method::POST, path);
|
|
req.headers.extend(extra_headers.clone());
|
|
req.headers.insert(
|
|
http::header::ACCEPT,
|
|
http::HeaderValue::from_static("text/event-stream"),
|
|
);
|
|
req.body = Some(body.clone());
|
|
req.compression = compression;
|
|
add_auth_headers(&self.auth, req)
|
|
};
|
|
|
|
let stream_response = run_with_request_telemetry(
|
|
self.provider.retry.to_policy(),
|
|
self.request_telemetry.clone(),
|
|
builder,
|
|
|req| self.transport.stream(req),
|
|
)
|
|
.await?;
|
|
|
|
Ok(spawner(
|
|
stream_response,
|
|
self.provider.stream_idle_timeout,
|
|
self.sse_telemetry.clone(),
|
|
))
|
|
}
|
|
}
|