Method execute_request_with_resilience

python/src/llm/client.rs:1019–1120

Execute a single request with retry logic and circuit breaker

(
        provider: Arc<RwLock<Box<dyn LlmProviderTrait>>>,
        circuit_breaker: Arc<CircuitBreaker>,
        stats: Arc<RwLock<ClientStats>>,
        config: ClientConfig,
        request: LlmReq

    /// Execute a single request with retry logic and circuit breaker
    async fn execute_request_with_resilience(
        provider: Arc<RwLock<Box<dyn LlmProviderTrait>>>,
        circuit_breaker: Arc<CircuitBreaker>,
        stats: Arc<RwLock<ClientStats>>,
        config: ClientConfig,
        request: LlmRequest,
    ) -> Result<graphbit_core::llm::LlmResponse, PyErr> {
        let start_time = Instant::now();

        // Update stats
        {
            let mut stats_guard = stats.write().await;
            stats_guard.total_requests += 1;
        }

        // Check circuit breaker
        if !circuit_breaker.can_execute().await {
            return Err(PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(
                "Circuit breaker is open, request rejected",
            ));
        }

        let mut last_error = None;
        let mut delay = config.base_retry_delay;

        for attempt in 0..=config.max_retries {
            if config.debug {
                debug!("Executing LLM request (attempt {})", attempt + 1);
            }

            let result = timeout(config.request_timeout, async {
                let guard = provider.read().await;
                guard.complete(request.clone()).await
            })
            .await;

            match result {
                Ok(Ok(response)) => {
                    // Success - update stats and circuit breaker
                    let duration = start_time.elapsed();

                    {
                        let mut stats_guard = stats.write().await;
                        stats_guard.successful_requests += 1;

                        // Update average response time (simple moving average)
                        let total_requests = stats_guard.total_requests as f64;
                        stats_guard.average_response_time_ms =
                            (stats_guard.average_response_time_ms * (total_requests - 1.0)
                                + duration.as_millis() as f64)
                                / total_requests;
                    }

                    circuit_breaker.record_success().await;
                    if config.debug {
                        info!("LLM request completed successfully in {:?}", duration);
                    }