Method complete

core/src/llm/anthropic.rs:235–307

(&self, request: LlmRequest)

    }

    async fn complete(&self, request: LlmRequest) -> GraphBitResult<LlmResponse> {
        let url = format!("{}/messages", self.base_url);

        let enable_caching = request.enable_prompt_caching;
        let (system_prompt, messages) = Self::convert_messages(&request.messages, enable_caching);

        // Convert tools to `Anthropic` format, adding cache_control to the last tool
        // when prompt caching is enabled (caches the entire tool-definition block).
        let tools: Option<Vec<AnthropicTool>> = if request.tools.is_empty() {
            tracing::info!("No tools provided in request");
            None
        } else {
            tracing::info!("Converting {} tools for Anthropic", request.tools.len());
            let last_idx = request.tools.len() - 1;
            Some(
                request
                    .tools
                    .iter()
                    .enumerate()
                    .map(|(i, t)| Self::convert_tool(t, enable_caching && i == last_idx))
                    .collect(),
            )
        };

        let body = AnthropicRequest {
            model: self.model.clone(),
            max_tokens: request.max_tokens.unwrap_or(4096),
            messages,
            system: system_prompt,
            temperature: request.temperature,
            top_p: request.top_p,
            tools,
        };

        tracing::info!(
            "Sending request to Anthropic with {} tools (prompt_caching={})",
            body.tools.as_ref().map_or(0, Vec::len),
            enable_caching
        );

        let mut req_builder = self
            .client
            .post(&url)
            .header("x-api-key", &self.api_key)
            .header("Content-Type", "application/json")
            .header("anthropic-version", "2023-06-01");

        if enable_caching {
            req_builder =
                req_builder.header("anthropic-beta", "prompt-caching-2024-07-31");
        }

        let response = req_builder.json(&body).send().await.map_err(|e| {
            GraphBitError::llm_provider("anthropic", format!("Request failed: {e}"))
        })?;

        if !response.status().is_success() {
            let error_text = response