Method stream

core/src/llm/openai.rs:276–724

(
        &self,
        request: LlmRequest,
    )

    }

    async fn stream(
        &self,
        request: LlmRequest,
    ) -> GraphBitResult<Box<dyn Stream<Item = GraphBitResult<LlmResponse>> + Unpin + Send>> {
        let url = format!("{}/chat/completions", self.base_url);

        let messages: Vec<OpenAiMessage> =
            request.messages.iter().map(Self::convert_message).collect();

        let tools: Option<Vec<OpenAiTool>> = if request.tools.is_empty() {
            None
        } else {
            Some(request.tools.iter().map(Self::convert_tool).collect())
        };

        let body = OpenAiRequest {
            model: self.model.clone(),
            messages,
            max_completion_tokens: request.max_tokens,
            temperature: request.temperature,
            top_p: request.top_p,
            tools: tools.clone(),
            tool_choice: if tools.is_some() {
                Some("auto".to_string())
            } else {
                None
            },
            stream: Some(true), // Enable streaming
            // Request terminal usage chunk so workflow metadata token usage matches non-streaming.
            stream_options: Some(OpenAiStreamOptions {
                include_usage: true,
            }),
        };

        // Add extra parameters
        let mut request_json = serde_json::to_value(&body)?;
        if let serde_json::Value::Object(ref mut map) = request_json {
            for (key, value) in request.extra_params {
                map.insert(key, value);
            }
        }

        let mut req_builder = self
            .client
            .post(&url)
            .header("Authorization", format!("Bearer {}", self.api_key))
            .header("Content-Type", "application/json")
            .json(&request_json);

        if let Some(org) = &self.organization {
            req_builder = req_builder.header("OpenAI-Organization", org);
        }

        // Timeout constants for different phases of the request
        // CONNECTION_TIMEOUT: Covers DNS resolution, TCP connection, TLS handshake, and first byte
        // Should be generous for slow networks but prevent infinite hangs
        const CONNECTION_TIMEOUT: Duration = Duration::from_secs(60);
        // ERROR_BODY_TIMEOUT: Time to read error response body (usually small)