Method stream

core/src/llm/anthropic.rs:322–613

(
        &self,
        request: LlmRequest,
    )

    }

    async fn stream(
        &self,
        request: LlmRequest,
    ) -> GraphBitResult<Box<dyn Stream<Item = GraphBitResult<LlmResponse>> + Unpin + Send>> {
        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
        let tools: Option<Vec<AnthropicTool>> = if request.tools.is_empty() {
            None
        } else {
            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 = AnthropicStreamRequest {
            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,
            stream: true, // Enable streaming
        };

        // Timeout constants for different phases of the request
        const CONNECTION_TIMEOUT: Duration = Duration::from_secs(60);
        const ERROR_BODY_TIMEOUT: Duration = Duration::from_secs(10);
        const CHUNK_TIMEOUT: Duration = Duration::from_secs(30);

        // Apply timeout to initial connection
        let mut stream_req = 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 {
            stream_req =
                stream_req.header("anthropic-beta", "prompt-caching-2024-07-31");
        }

        let response = timeout(CONNECTION_TIMEOUT, stream_req.json(&body).send())
        .await
        .map_err(|_| {
            GraphBitError::llm_provider(
                "anthropic",