feat: add HttpClient trait for middleware support

- Add HttpClient trait to abstract HTTP operations
- Implement trait for reqwest::Client
- Add with_http_client_trait method to Client
- Export ClientWithTrait for middleware-enabled clients
- Add async-trait dependency

This enables using middleware-enabled HTTP clients with async-openai,
allowing automatic instrumentation, retry logic, and other middleware features.

Author: timvw

async-openai/Cargo.toml

@@ -28,6 +28,7 @@ byot = []
 
 [dependencies]
 async-openai-macros = { path = "../async-openai-macros", version = "0.1.0" }
+async-trait = "0.1"
 backoff = { version = "0.4.0", features = ["tokio"] }
 base64 = "0.22.1"
 futures = "0.3.31"

async-openai/src/client.rs

@@ -10,6 +10,7 @@ use crate::{
     config::{Config, OpenAIConfig},
     error::{map_deserialization_error, ApiError, OpenAIError, WrappedError},
     file::Files,
+    http_client::{HttpClient, BoxedHttpClient},
     image::Images,
     moderation::Moderations,
     traits::AsyncTryFrom,
@@ -63,6 +64,16 @@ impl<C: Config> Client<C> {
         self.http_client = http_client;
         self
     }
+    
+    /// Provide any HTTP client implementing the HttpClient trait
+    /// This allows using middleware-enabled clients for automatic instrumentation
+    pub fn with_http_client_trait<H: HttpClient + 'static>(self, http_client: H) -> ClientWithTrait<C> {
+        ClientWithTrait {
+            http_client: std::sync::Arc::new(http_client),
+            config: self.config,
+            backoff: self.backoff,
+        }
+    }
 
     /// Exponential backoff for retrying [rate limited](https://platform.openai.com/docs/guides/rate-limits) requests.
     pub fn with_backoff(mut self, backoff: backoff::ExponentialBackoff) -> Self {

async-openai/src/http_client.rs

@@ -0,0 +1,89 @@
+/// HTTP client abstraction trait for async-openai
+/// This allows using any HTTP client implementation, including those with middleware
+use async_trait::async_trait;
+use bytes::Bytes;
+use reqwest::{Method, StatusCode, Url, header::HeaderMap};
+use std::error::Error as StdError;
+use std::fmt;
+use std::sync::Arc;
+
+/// Error type for HTTP operations
+#[derive(Debug)]
+pub struct HttpError {
+    pub message: String,
+    pub status: Option<StatusCode>,
+}
+
+impl fmt::Display for HttpError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.status {
+            Some(status) => write!(f, "HTTP {}: {}", status, self.message),
+            None => write!(f, "{}", self.message),
+        }
+    }
+}
+
+impl StdError for HttpError {}
+
+impl From<reqwest::Error> for HttpError {
+    fn from(err: reqwest::Error) -> Self {
+        HttpError {
+            message: err.to_string(),
+            status: err.status(),
+        }
+    }
+}
+
+/// Response from HTTP client
+pub struct HttpResponse {
+    pub status: StatusCode,
+    pub headers: HeaderMap,
+    pub body: Bytes,
+}
+
+/// Trait for HTTP clients
+/// This abstraction allows using reqwest::Client, ClientWithMiddleware, or any custom implementation
+#[async_trait]
+pub trait HttpClient: Send + Sync {
+    /// Send an HTTP request
+    async fn request(
+        &self,
+        method: Method,
+        url: Url,
+        headers: HeaderMap,
+        body: Option<Bytes>,
+    ) -> Result<HttpResponse, HttpError>;
+}
+
+/// Type alias for boxed HTTP client
+pub type BoxedHttpClient = Arc<dyn HttpClient>;
+
+/// Implementation for standard reqwest::Client
+#[async_trait]
+impl HttpClient for reqwest::Client {
+    async fn request(
+        &self,
+        method: Method,
+        url: Url,
+        headers: HeaderMap,
+        body: Option<Bytes>,
+    ) -> Result<HttpResponse, HttpError> {
+        let mut request = self.request(method, url).headers(headers);
+        
+        if let Some(body) = body {
+            request = request.body(body);
+        }
+        
+        let response = request.send().await?;
+        
+        let status = response.status();
+        let headers = response.headers().clone();
+        let body = response.bytes().await?;
+        
+        Ok(HttpResponse {
+            status,
+            headers,
+            body,
+        })
+    }
+}

async-openai/src/lib.rs

@@ -150,6 +150,7 @@ mod completion;
 pub mod config;
 mod download;
 mod embedding;
+pub mod http_client;
 pub mod error;
 mod file;
 mod fine_tuning;
@@ -180,7 +181,7 @@ pub use audio::Audio;
 pub use audit_logs::AuditLogs;
 pub use batches::Batches;
 pub use chat::Chat;
-pub use client::Client;
+pub use client::{Client, ClientWithTrait};
 pub use completion::Completions;
 pub use embedding::Embeddings;
 pub use file::Files;