Method complete_full_async

python/src/llm/client.rs:883–954

(
        &self,
        prompt: String,
        max_tokens: Option<i64>,
        temperature: Option<f64>,
        enable_prompt_caching: bool,
        py: Python<'a>,
    )

    #[instrument(skip(self, py), fields(prompt_len = prompt.len()))]
    #[pyo3(signature = (prompt, max_tokens=None, temperature=None, enable_prompt_caching=false))]
    fn complete_full_async<'a>(
        &self,
        prompt: String,
        max_tokens: Option<i64>,
        temperature: Option<f64>,
        enable_prompt_caching: bool,
        py: Python<'a>,
    ) -> PyResult<Bound<'a, PyAny>> {
        // Validate input
        if prompt.is_empty() {
            return Err(validation_error(
                "prompt",
                Some(&prompt),
                "Prompt cannot be empty",
            ));
        }

        let validated_max_tokens = max_tokens
            .map(|t| {
                if t <= 0 {
                    Err(validation_error(
                        "max_tokens",
                        Some(&t.to_string()),
                        "max_tokens must be positive",
                    ))
                } else if t > 100_000 {
                    Err(validation_error(
                        "max_tokens",
                        Some(&t.to_string()),
                        "max_tokens cannot exceed 100,000",
                    ))
                } else {
                    Ok(t as u32)
                }
            })
            .transpose()?;

        let validated_temperature = temperature
            .map(|t| {
                if !(0.0..=2.0).contains(&t) {
                    Err(validation_error(
                        "temperature",
                        Some(&t.to_string()),
                        "temperature must be between 0.0 and 2.0",
                    ))
                } else {
                    Ok(t as f32)
                }
            })
            .transpose()?;

        let provider = Arc::clone(&self.provider);
        let circuit_breaker = Arc::clone(&self.circuit_breaker);
        let stats = Arc::clone(&self.stats);
        let config = self.config.clone();

        pyo3_async_runtimes::tokio::future_into_py(py, async move {
            let response = Self::execute_with_resilience_full(