fix(core): remove retry logic

Author: itzlambda

crates/rullm-core/src/middleware.rs

@@ -1,12 +1,11 @@
-use crate::config::{ProviderConfig, RetryPolicy};
+use crate::config::RetryPolicy;
 use crate::error::LlmError;
 use crate::types::{
     ChatCompletion, ChatRequest, ChatResponse, ChatStreamEvent, StreamConfig, StreamResult,
 };
 use futures::Stream;
 use metrics::{counter, histogram};
 
-use std::collections::HashMap;
 use std::pin::Pin;
 use std::time::{Duration, Instant};
 
@@ -170,325 +169,9 @@ where
     }
 }
 
-/// Enhanced HTTP client that handles timeout and retries
-#[derive(Clone)]
-pub struct EnhancedHttpClient {
-    client: reqwest::Client,
-    retry_policy: RetryPolicy,
-    max_retries: u32,
-}
-
-impl EnhancedHttpClient {
-    pub fn new<C: ProviderConfig>(config: &C) -> Result<Self, LlmError> {
-        let client = reqwest::Client::builder()
-            .timeout(config.timeout())
-            .build()
-            .map_err(|e| LlmError::configuration(format!("Failed to create HTTP client: {e}")))?;
-
-        Ok(Self {
-            client,
-            retry_policy: config.retry_policy(),
-            max_retries: config.max_retries(),
-        })
-    }
-
-    /// Execute a GET request with retry logic
-    pub async fn get_with_retry(
-        &self,
-        url: &str,
-        headers: &HashMap<String, String>,
-    ) -> Result<reqwest::Response, LlmError> {
-        let mut attempt = 0;
-
-        loop {
-            let mut req = self.client.get(url);
-            for (key, value) in headers {
-                req = req.header(key, value);
-            }
-
-            match req.send().await {
-                Ok(response) => {
-                    if response.status().is_success() {
-                        if attempt > 0 {
-                            log::info!("GET request to {url} succeeded after {attempt} retries");
-                        }
-                        return Ok(response);
-                    }
-
-                    // Check if we should retry based on status code
-                    let status_code = response.status().as_u16();
-                    let should_retry = status_code >= 500 || status_code == 429;
-
-                    if !should_retry || attempt >= self.max_retries {
-                        if !should_retry {
-                            log::debug!(
-                                "GET request to {url} returned non-retryable status: {status_code}"
-                            );
-                        } else {
-                            log::warn!(
-                                "GET request to {} failed after {} retries, status: {}",
-                                url,
-                                self.max_retries,
-                                status_code
-                            );
-                        }
-                        return Ok(response); // Return the error response
-                    }
-
-                    // Calculate delay and retry
-                    let delay = self.calculate_delay(attempt, Some(&response)).await;
-                    let retry_info = RetryInfo {
-                        attempt: attempt + 1,
-                        max_retries: self.max_retries,
-                        delay,
-                        reason: format!("HTTP {status_code}"),
-                        response_status: Some(status_code),
-                    };
-
-                    log::info!(
-                        "Retrying GET request to {} (attempt {}/{}): {} - waiting {:?}",
-                        url,
-                        retry_info.attempt,
-                        retry_info.max_retries,
-                        retry_info.reason,
-                        retry_info.delay
-                    );
-
-                    tokio::time::sleep(delay).await;
-                    attempt += 1;
-                }
-                Err(e) => {
-                    // Retry on network errors
-                    if attempt >= self.max_retries {
-                        log::error!(
-                            "GET request to {} failed after {} retries due to network error: {}",
-                            url,
-                            self.max_retries,
-                            e
-                        );
-                        return Err(LlmError::network(format!(
-                            "Request failed after {} retries: {}",
-                            self.max_retries, e
-                        )));
-                    }
-
-                    let delay = self.calculate_delay(attempt, None).await;
-                    let retry_info = RetryInfo {
-                        attempt: attempt + 1,
-                        max_retries: self.max_retries,
-                        delay,
-                        reason: format!("Network error: {e}"),
-                        response_status: None,
-                    };
-
-                    log::warn!(
-                        "Retrying GET request to {} due to network error (attempt {}/{}): {} - waiting {:?}",
-                        url,
-                        retry_info.attempt,
-                        retry_info.max_retries,
-                        retry_info.reason,
-                        retry_info.delay
-                    );
-
-                    tokio::time::sleep(delay).await;
-                    attempt += 1;
-                }
-            }
-        }
-    }
-
-    /// Execute a POST request with retry logic
-    pub async fn post_with_retry(
-        &self,
-        url: &str,
-        headers: &HashMap<String, String>,
-        body: serde_json::Value,
-    ) -> Result<reqwest::Response, LlmError> {
-        let mut attempt = 0;
-
-        loop {
-            let mut req = self.client.post(url);
-            for (key, value) in headers {
-                req = req.header(key, value);
-            }
-            req = req.json(&body);
-
-            match req.send().await {
-                Ok(response) => {
-                    if response.status().is_success() {
-                        if attempt > 0 {
-                            log::info!("POST request to {url} succeeded after {attempt} retries");
-                        }
-                        return Ok(response);
-                    }
-
-                    // Check if we should retry based on status code
-                    let status_code = response.status().as_u16();
-                    let should_retry = status_code >= 500 || status_code == 429;
-
-                    if !should_retry || attempt >= self.max_retries {
-                        if !should_retry {
-                            log::debug!(
-                                "POST request to {url} returned non-retryable status: {status_code}"
-                            );
-                        } else {
-                            log::warn!(
-                                "POST request to {} failed after {} retries, status: {}",
-                                url,
-                                self.max_retries,
-                                status_code
-                            );
-                        }
-                        return Ok(response); // Return the error response
-                    }
-
-                    // Calculate delay and retry
-                    let delay = self.calculate_delay(attempt, Some(&response)).await;
-                    let retry_info = RetryInfo {
-                        attempt: attempt + 1,
-                        max_retries: self.max_retries,
-                        delay,
-                        reason: format!("HTTP {status_code}"),
-                        response_status: Some(status_code),
-                    };
-
-                    log::info!(
-                        "Retrying POST request to {} (attempt {}/{}): {} - waiting {:?}",
-                        url,
-                        retry_info.attempt,
-                        retry_info.max_retries,
-                        retry_info.reason,
-                        retry_info.delay
-                    );
-
-                    tokio::time::sleep(delay).await;
-                    attempt += 1;
-                }
-                Err(e) => {
-                    // Retry on network errors
-                    if attempt >= self.max_retries {
-                        log::error!(
-                            "POST request to {} failed after {} retries due to network error: {}",
-                            url,
-                            self.max_retries,
-                            e
-                        );
-                        return Err(LlmError::network(format!(
-                            "Request failed after {} retries: {}",
-                            self.max_retries, e
-                        )));
-                    }
-
-                    let delay = self.calculate_delay(attempt, None).await;
-                    let retry_info = RetryInfo {
-                        attempt: attempt + 1,
-                        max_retries: self.max_retries,
-                        delay,
-                        reason: format!("Network error: {e}"),
-                        response_status: None,
-                    };
-
-                    log::warn!(
-                        "Retrying POST request to {} due to network error (attempt {}/{}): {} - waiting {:?}",
-                        url,
-                        retry_info.attempt,
-                        retry_info.max_retries,
-                        retry_info.reason,
-                        retry_info.delay
-                    );
-
-                    tokio::time::sleep(delay).await;
-                    attempt += 1;
-                }
-            }
-        }
-    }
-
-    async fn calculate_delay(
-        &self,
-        attempt: u32,
-        response: Option<&reqwest::Response>,
-    ) -> Duration {
-        match &self.retry_policy {
-            RetryPolicy::Fixed { delay_ms } => Duration::from_millis(*delay_ms),
-
-            RetryPolicy::ExponentialBackoff {
-                initial_delay_ms,
-                max_delay_ms,
-                multiplier,
-                jitter,
-            } => {
-                let base_delay = *initial_delay_ms as f64 * multiplier.powi(attempt as i32);
-                let delay_ms = base_delay.min(*max_delay_ms as f64) as u64;
-
-                let final_delay = if *jitter {
-                    // Add ±25% jitter
-                    let jitter_factor = 0.75 + (rand::random::<f64>() * 0.5);
-                    (delay_ms as f64 * jitter_factor) as u64
-                } else {
-                    delay_ms
-                };
-
-                Duration::from_millis(final_delay)
-            }
-
-            RetryPolicy::ApiGuided {
-                fallback,
-                max_api_delay_ms,
-                retry_headers,
-            } => {
-                // Try to parse delay from response headers
-                if let Some(resp) = response {
-                    let headers: HashMap<String, String> = resp
-                        .headers()
-                        .iter()
-                        .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
-                        .collect();
-
-                    if let Some(api_delay) = crate::config::retry_parsing::parse_retry_delay(
-                        &headers,
-                        retry_headers,
-                        *max_api_delay_ms,
-                    ) {
-                        return api_delay;
-                    }
-                }
-
-                // Fall back to the configured fallback policy
-                match &**fallback {
-                    RetryPolicy::Fixed { delay_ms } => Duration::from_millis(*delay_ms),
-                    RetryPolicy::ExponentialBackoff {
-                        initial_delay_ms,
-                        max_delay_ms,
-                        multiplier,
-                        jitter,
-                    } => {
-                        let base_delay = *initial_delay_ms as f64 * multiplier.powi(attempt as i32);
-                        let delay_ms = base_delay.min(*max_delay_ms as f64) as u64;
-
-                        let final_delay = if *jitter {
-                            let jitter_factor = 0.75 + (rand::random::<f64>() * 0.5);
-                            (delay_ms as f64 * jitter_factor) as u64
-                        } else {
-                            delay_ms
-                        };
-
-                        Duration::from_millis(final_delay)
-                    }
-                    RetryPolicy::ApiGuided { .. } => {
-                        // For nested ApiGuided policies, use simple exponential backoff
-                        Duration::from_millis(1000 * 2_u64.pow(attempt))
-                    }
-                }
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::config::OpenAIConfig;
 
     #[test]
     fn test_retry_info_creation() {
@@ -506,49 +189,6 @@ mod tests {
         assert_eq!(retry_info.reason, "HTTP 500");
         assert_eq!(retry_info.response_status, Some(500));
     }
-
-    #[test]
-    fn test_enhanced_http_client_creation() {
-        let config = OpenAIConfig::new("test-key");
-        let client = EnhancedHttpClient::new(&config);
-
-        assert!(client.is_ok());
-        let client = client.unwrap();
-        assert_eq!(client.max_retries, 3); // Default from config
-    }
-
-    #[test]
-    fn test_calculate_delay_fixed_policy() {
-        let config = OpenAIConfig::new("test-key").with_fixed_retry(3, 100);
-        let client = EnhancedHttpClient::new(&config).unwrap();
-
-        // Use a dummy async runtime for testing delay calculation
-        let rt = tokio::runtime::Runtime::new().unwrap();
-        let delay = rt.block_on(async { client.calculate_delay(0, None).await });
-
-        assert_eq!(delay, Duration::from_millis(100));
-    }
-
-    #[test]
-    fn test_calculate_delay_exponential_backoff() {
-        let config =
-            OpenAIConfig::new("test-key").with_exponential_backoff(3, 100, 1000, 2.0, false);
-        let client = EnhancedHttpClient::new(&config).unwrap();
-
-        let rt = tokio::runtime::Runtime::new().unwrap();
-
-        // Test first attempt (should be initial delay)
-        let delay1 = rt.block_on(async { client.calculate_delay(0, None).await });
-        assert_eq!(delay1, Duration::from_millis(100));
-
-        // Test second attempt (should be 200ms = 100 * 2^1)
-        let delay2 = rt.block_on(async { client.calculate_delay(1, None).await });
-        assert_eq!(delay2, Duration::from_millis(200));
-
-        // Test third attempt (should be 400ms = 100 * 2^2)
-        let delay3 = rt.block_on(async { client.calculate_delay(2, None).await });
-        assert_eq!(delay3, Duration::from_millis(400));
-    }
 }
 
 /// Middleware configuration for LLM providers