chore: proper client extraction (#6996)

codex-rs/codex-client/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "codex-client"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+async-trait = { workspace = true }
+bytes = { workspace = true }
+futures = { workspace = true }
+http = { workspace = true }
+reqwest = { workspace = true, features = ["json", "stream"] }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt", "time", "sync"] }
+rand = { workspace = true }
+eventsource-stream = { workspace = true }
+
+[lints]
+workspace = true

codex-rs/codex-client/README.md

@@ -0,0 +1,8 @@
+# codex-client
+
+Generic transport layer that wraps HTTP requests, retries, and streaming primitives without any Codex/OpenAI awareness.
+
+- Defines `HttpTransport` and a default `ReqwestTransport` plus thin `Request`/`Response` types.
+- Provides retry utilities (`RetryPolicy`, `RetryOn`, `run_with_retry`, `backoff`) that callers plug into for unary and streaming calls.
+- Supplies the `sse_stream` helper to turn byte streams into raw SSE `data:` frames with idle timeouts and surfaced stream errors.
+- Consumed by higher-level crates like `codex-api`; it stays neutral on endpoints, headers, or API-specific error shapes.

codex-rs/codex-client/src/error.rs

@@ -0,0 +1,29 @@
+use http::HeaderMap;
+use http::StatusCode;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum TransportError {
+    #[error("http {status}: {body:?}")]
+    Http {
+        status: StatusCode,
+        headers: Option<HeaderMap>,
+        body: Option<String>,
+    },
+    #[error("retry limit reached")]
+    RetryLimit,
+    #[error("timeout")]
+    Timeout,
+    #[error("network error: {0}")]
+    Network(String),
+    #[error("request build error: {0}")]
+    Build(String),
+}
+
+#[derive(Debug, Error)]
+pub enum StreamError {
+    #[error("stream failed: {0}")]
+    Stream(String),
+    #[error("timeout")]
+    Timeout,
+}

codex-rs/codex-client/src/lib.rs

@@ -0,0 +1,21 @@
+mod error;
+mod request;
+mod retry;
+mod sse;
+mod telemetry;
+mod transport;
+
+pub use crate::error::StreamError;
+pub use crate::error::TransportError;
+pub use crate::request::Request;
+pub use crate::request::Response;
+pub use crate::retry::RetryOn;
+pub use crate::retry::RetryPolicy;
+pub use crate::retry::backoff;
+pub use crate::retry::run_with_retry;
+pub use crate::sse::sse_stream;
+pub use crate::telemetry::RequestTelemetry;
+pub use crate::transport::ByteStream;
+pub use crate::transport::HttpTransport;
+pub use crate::transport::ReqwestTransport;
+pub use crate::transport::StreamResponse;

codex-rs/codex-client/src/request.rs

@@ -0,0 +1,39 @@
+use bytes::Bytes;
+use http::Method;
+use reqwest::header::HeaderMap;
+use serde::Serialize;
+use serde_json::Value;
+use std::time::Duration;
+
+#[derive(Debug, Clone)]
+pub struct Request {
+    pub method: Method,
+    pub url: String,
+    pub headers: HeaderMap,
+    pub body: Option<Value>,
+    pub timeout: Option<Duration>,
+}
+
+impl Request {
+    pub fn new(method: Method, url: String) -> Self {
+        Self {
+            method,
+            url,
+            headers: HeaderMap::new(),
+            body: None,
+            timeout: None,
+        }
+    }
+
+    pub fn with_json<T: Serialize>(mut self, body: &T) -> Self {
+        self.body = serde_json::to_value(body).ok();
+        self
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Response {
+    pub status: http::StatusCode,
+    pub headers: HeaderMap,
+    pub body: Bytes,
+}

codex-rs/codex-client/src/retry.rs

@@ -0,0 +1,73 @@
+use crate::error::TransportError;
+use crate::request::Request;
+use rand::Rng;
+use std::future::Future;
+use std::time::Duration;
+use tokio::time::sleep;
+
+#[derive(Debug, Clone)]
+pub struct RetryPolicy {
+    pub max_attempts: u64,
+    pub base_delay: Duration,
+    pub retry_on: RetryOn,
+}
+
+#[derive(Debug, Clone)]
+pub struct RetryOn {
+    pub retry_429: bool,
+    pub retry_5xx: bool,
+    pub retry_transport: bool,
+}
+
+impl RetryOn {
+    pub fn should_retry(&self, err: &TransportError, attempt: u64, max_attempts: u64) -> bool {
+        if attempt >= max_attempts {
+            return false;
+        }
+        match err {
+            TransportError::Http { status, .. } => {
+                (self.retry_429 && status.as_u16() == 429)
+                    || (self.retry_5xx && status.is_server_error())
+            }
+            TransportError::Timeout | TransportError::Network(_) => self.retry_transport,
+            _ => false,
+        }
+    }
+}
+
+pub fn backoff(base: Duration, attempt: u64) -> Duration {
+    if attempt == 0 {
+        return base;
+    }
+    let exp = 2u64.saturating_pow(attempt as u32 - 1);
+    let millis = base.as_millis() as u64;
+    let raw = millis.saturating_mul(exp);
+    let jitter: f64 = rand::rng().random_range(0.9..1.1);
+    Duration::from_millis((raw as f64 * jitter) as u64)
+}
+
+pub async fn run_with_retry<T, F, Fut>(
+    policy: RetryPolicy,
+    mut make_req: impl FnMut() -> Request,
+    op: F,
+) -> Result<T, TransportError>
+where
+    F: Fn(Request, u64) -> Fut,
+    Fut: Future<Output = Result<T, TransportError>>,
+{
+    for attempt in 0..=policy.max_attempts {
+        let req = make_req();
+        match op(req, attempt).await {
+            Ok(resp) => return Ok(resp),
+            Err(err)
+                if policy
+                    .retry_on
+                    .should_retry(&err, attempt, policy.max_attempts) =>
+            {
+                sleep(backoff(policy.base_delay, attempt + 1)).await;
+            }
+            Err(err) => return Err(err),
+        }
+    }
+    Err(TransportError::RetryLimit)
+}

codex-rs/codex-client/src/sse.rs

@@ -0,0 +1,48 @@
+use crate::error::StreamError;
+use crate::transport::ByteStream;
+use eventsource_stream::Eventsource;
+use futures::StreamExt;
+use tokio::sync::mpsc;
+use tokio::time::Duration;
+use tokio::time::timeout;
+
+/// Minimal SSE helper that forwards raw `data:` frames as UTF-8 strings.
+///
+/// Errors and idle timeouts are sent as `Err(StreamError)` before the task exits.
+pub fn sse_stream(
+    stream: ByteStream,
+    idle_timeout: Duration,
+    tx: mpsc::Sender<Result<String, StreamError>>,
+) {
+    tokio::spawn(async move {
+        let mut stream = stream
+            .map(|res| res.map_err(|e| StreamError::Stream(e.to_string())))
+            .eventsource();
+
+        loop {
+            match timeout(idle_timeout, stream.next()).await {
+                Ok(Some(Ok(ev))) => {
+                    if tx.send(Ok(ev.data.clone())).await.is_err() {
+                        return;
+                    }
+                }
+                Ok(Some(Err(e))) => {
+                    let _ = tx.send(Err(StreamError::Stream(e.to_string()))).await;
+                    return;
+                }
+                Ok(None) => {
+                    let _ = tx
+                        .send(Err(StreamError::Stream(
+                            "stream closed before completion".into(),
+                        )))
+                        .await;
+                    return;
+                }
+                Err(_) => {
+                    let _ = tx.send(Err(StreamError::Timeout)).await;
+                    return;
+                }
+            }
+        }
+    });
+}

codex-rs/codex-client/src/telemetry.rs

@@ -0,0 +1,14 @@
+use crate::error::TransportError;
+use http::StatusCode;
+use std::time::Duration;
+
+/// API specific telemetry.
+pub trait RequestTelemetry: Send + Sync {
+    fn on_request(
+        &self,
+        attempt: u64,
+        status: Option<StatusCode>,
+        error: Option<&TransportError>,
+        duration: Duration,
+    );
+}

codex-rs/codex-client/src/transport.rs

@@ -0,0 +1,107 @@
+use crate::error::TransportError;
+use crate::request::Request;
+use crate::request::Response;
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures::StreamExt;
+use futures::stream::BoxStream;
+use http::HeaderMap;
+use http::Method;
+use http::StatusCode;
+
+pub type ByteStream = BoxStream<'static, Result<Bytes, TransportError>>;
+
+pub struct StreamResponse {
+    pub status: StatusCode,
+    pub headers: HeaderMap,
+    pub bytes: ByteStream,
+}
+
+#[async_trait]
+pub trait HttpTransport: Send + Sync {
+    async fn execute(&self, req: Request) -> Result<Response, TransportError>;
+    async fn stream(&self, req: Request) -> Result<StreamResponse, TransportError>;
+}
+
+#[derive(Clone, Debug)]
+pub struct ReqwestTransport {
+    client: reqwest::Client,
+}
+
+impl ReqwestTransport {
+    pub fn new(client: reqwest::Client) -> Self {
+        Self { client }
+    }
+
+    fn build(&self, req: Request) -> Result<reqwest::RequestBuilder, TransportError> {
+        let mut builder = self
+            .client
+            .request(
+                Method::from_bytes(req.method.as_str().as_bytes()).unwrap_or(Method::GET),
+                &req.url,
+            )
+            .headers(req.headers);
+        if let Some(timeout) = req.timeout {
+            builder = builder.timeout(timeout);
+        }
+        if let Some(body) = req.body {
+            builder = builder.json(&body);
+        }
+        Ok(builder)
+    }
+
+    fn map_error(err: reqwest::Error) -> TransportError {
+        if err.is_timeout() {
+            TransportError::Timeout
+        } else {
+            TransportError::Network(err.to_string())
+        }
+    }
+}
+
+#[async_trait]
+impl HttpTransport for ReqwestTransport {
+    async fn execute(&self, req: Request) -> Result<Response, TransportError> {
+        let builder = self.build(req)?;
+        let resp = builder.send().await.map_err(Self::map_error)?;
+        let status = resp.status();
+        let headers = resp.headers().clone();
+        let bytes = resp.bytes().await.map_err(Self::map_error)?;
+        if !status.is_success() {
+            let body = String::from_utf8(bytes.to_vec()).ok();
+            return Err(TransportError::Http {
+                status,
+                headers: Some(headers),
+                body,
+            });
+        }
+        Ok(Response {
+            status,
+            headers,
+            body: bytes,
+        })
+    }
+
+    async fn stream(&self, req: Request) -> Result<StreamResponse, TransportError> {
+        let builder = self.build(req)?;
+        let resp = builder.send().await.map_err(Self::map_error)?;
+        let status = resp.status();
+        let headers = resp.headers().clone();
+        if !status.is_success() {
+            let body = resp.text().await.ok();
+            return Err(TransportError::Http {
+                status,
+                headers: Some(headers),
+                body,
+            });
+        }
+        let stream = resp
+            .bytes_stream()
+            .map(|result| result.map_err(Self::map_error));
+        Ok(StreamResponse {
+            status,
+            headers,
+            bytes: Box::pin(stream),
+        })
+    }
+}