feat: clean codex-api part 1 (#10501)

codex-rs/codex-api/src/endpoint/responses.rs

@@ -3,7 +3,7 @@ use crate::common::Prompt as ApiPrompt;
 use crate::common::Reasoning;
 use crate::common::ResponseStream;
 use crate::common::TextControls;
-use crate::endpoint::streaming::StreamingClient;
+use crate::endpoint::session::EndpointSession;
 use crate::error::ApiError;
 use crate::provider::Provider;
 use crate::requests::ResponsesRequest;
@@ -16,13 +16,16 @@ use codex_client::RequestCompression;
 use codex_client::RequestTelemetry;
 use codex_protocol::protocol::SessionSource;
 use http::HeaderMap;
+use http::HeaderValue;
+use http::Method;
 use serde_json::Value;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use tracing::instrument;
 
 pub struct ResponsesClient<T: HttpTransport, A: AuthProvider> {
-    streaming: StreamingClient<T, A>,
+    session: EndpointSession<T, A>,
+    sse_telemetry: Option<Arc<dyn SseTelemetry>>,
 }
 
 #[derive(Default)]
@@ -42,7 +45,8 @@ pub struct ResponsesOptions {
 impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
     pub fn new(transport: T, provider: Provider, auth: A) -> Self {
         Self {
-            streaming: StreamingClient::new(transport, provider, auth),
+            session: EndpointSession::new(transport, provider, auth),
+            sse_telemetry: None,
         }
     }
 
@@ -52,7 +56,8 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
         sse: Option<Arc<dyn SseTelemetry>>,
     ) -> Self {
         Self {
-            streaming: self.streaming.with_telemetry(request, sse),
+            session: self.session.with_request_telemetry(request),
+            sse_telemetry: sse,
         }
     }
 
@@ -102,12 +107,12 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
             .store_override(store_override)
             .extra_headers(extra_headers)
             .compression(compression)
-            .build(self.streaming.provider())?;
+            .build(self.session.provider())?;
 
         self.stream_request(request, turn_state).await
     }
 
-    fn path(&self) -> &'static str {
+    fn path() -> &'static str {
         "responses"
     }
 
@@ -118,20 +123,33 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
         compression: Compression,
         turn_state: Option<Arc<OnceLock<String>>>,
     ) -> Result<ResponseStream, ApiError> {
-        let compression = match compression {
+        let request_compression = match compression {
             Compression::None => RequestCompression::None,
             Compression::Zstd => RequestCompression::Zstd,
         };
 
-        self.streaming
-            .stream(
-                self.path(),
-                body,
+        let stream_response = self
+            .session
+            .stream_with(
+                Method::POST,
+                Self::path(),
                 extra_headers,
-                compression,
-                spawn_response_stream,
-                turn_state,
+                Some(body),
+                |req| {
+                    req.headers.insert(
+                        http::header::ACCEPT,
+                        HeaderValue::from_static("text/event-stream"),
+                    );
+                    req.compression = request_compression;
+                },
             )
-            .await
+            .await?;
+
+        Ok(spawn_response_stream(
+            stream_response,
+            self.session.provider().stream_idle_timeout,
+            self.sse_telemetry.clone(),
+            turn_state,
+        ))
     }
 }