ai_sdk_openai/chat/

model.rs

use ai_sdk_core::{CallOptions, Content, FinishReason, LanguageModel, Usage};
use ai_sdk_provider::language_model::{
    self, AssistantContentPart, Message, ResponseInfo, SourcePart, SourceType, TextPart,
    ToolCallPart, UserContentPart,
};
use ai_sdk_provider::{GenerateResponse, Result, StreamPart, StreamResponse};
use ai_sdk_provider_utils::merge_headers_reqwest;
use async_stream::stream;
use async_trait::async_trait;
use futures::stream::StreamExt;
use log::warn;
use reqwest::Client;
use std::collections::HashMap;

use crate::error::OpenAIError;

use crate::model_detection::{
    is_reasoning_model, is_search_preview_model, supports_flex_processing,
};
use crate::openai_config::{OpenAIConfig, OpenAIUrlOptions};

use super::{generate_source_id, options::OpenAIChatOptions};

/// OpenAI chat completion implementation of the language model interface.
///
/// This struct provides support for OpenAI's chat completion API, enabling text generation,
/// streaming, tool calling, and multi-modal capabilities. It handles conversion between
/// the unified SDK format and OpenAI's API specifications, including model-specific
/// behaviors for reasoning models, search preview models, and flex processing.
///
/// # Supported Features
/// - Text generation and streaming responses
/// - Function calling and tool use
/// - Multi-modal inputs (images, audio)
/// - JSON schema-based structured outputs
/// - Vision capabilities for supported models
/// - Reasoning effort customization for o1/o3 models
/// - Logit bias and probability tracking
/// - Token usage tracking including cached and reasoning tokens
///
/// # OpenAI-Specific Behaviors
/// - System messages are converted to developer messages for reasoning models (o1, o3)
/// - Temperature configuration is ignored for search preview models with a warning
/// - Reasoning models use `max_completion_tokens` instead of `max_tokens`
/// - Flex processing service tier validation for supported models
/// - Streaming includes usage information in the final chunk
pub struct OpenAIChatModel {
    model_id: String,
    config: OpenAIConfig,
    client: Client,
}

impl OpenAIChatModel {
    /// Creates a new OpenAI chat model instance.
    ///
    /// Initializes a language model that communicates with OpenAI's chat completion API.
    /// The model will automatically detect capabilities and apply model-specific
    /// configurations based on the provided model ID (e.g., reasoning for o1/o3,
    /// special handling for vision models).
    ///
    /// # Arguments
    /// * `model_id` - The OpenAI model identifier (e.g., "gpt-4o", "gpt-4-turbo",
    ///   "gpt-4", "gpt-3.5-turbo", "o1", "o1-mini", "o3-mini")
    /// * `config` - OpenAI configuration containing API endpoint, authentication headers,
    ///   and optional customizations
    ///
    /// # OpenAI Model Categories
    /// - **GPT-4o Series**: Latest high-capability models with vision and reasoning
    /// - **Reasoning Models (o1/o3)**: Enhanced reasoning with special parameter handling
    /// - **GPT-4 Series**: Advanced reasoning and code generation
    /// - **GPT-3.5 Turbo**: Balanced performance and cost-effectiveness
    /// - **Search Models**: Integration with web search capabilities
    ///
    /// # Example
    /// ```rust,ignore
    /// use ai_sdk_openai::{OpenAIConfig, OpenAIChatModel};
    ///
    /// let api_key = std::env::var("OPENAI_API_KEY").unwrap();
    /// let config = OpenAIConfig::from_api_key(api_key);
    /// let model = OpenAIChatModel::new("gpt-4o", config);
    /// ```
    pub fn new(model_id: impl Into<String>, config: impl Into<OpenAIConfig>) -> Self {
        Self {
            model_id: model_id.into(),
            config: config.into(),
            client: Client::new(),
        }
    }

    fn convert_prompt_to_messages(&self, prompt: &[Message]) -> Vec<crate::api_types::ChatMessage> {
        // Convert our prompt format to OpenAI's message format
        let mut openai_messages = Vec::new();

        for msg in prompt {
            match msg {
                Message::System { content } => {
                    // For reasoning models, convert system messages to developer messages
                    let role = if is_reasoning_model(&self.model_id) {
                        "developer"
                    } else {
                        "system"
                    };
                    openai_messages.push(crate::api_types::ChatMessage {
                        role: role.into(),
                        content: Some(crate::api_types::ChatMessageContent::Text(content.clone())),
                        tool_calls: None,
                        tool_call_id: None,
                        annotations: None,
                    });
                }
                Message::User { content } => {
                    // Check if we have any file content (multi-modal)
                    let has_files = content
                        .iter()
                        .any(|part| matches!(part, UserContentPart::File { .. }));

                    if has_files {
                        // Multi-modal message: convert to array of content parts
                        let mut openai_content = Vec::new();

                        for part in content {
                            match part {
                                UserContentPart::Text { text } => {
                                    openai_content.push(
                                        crate::multimodal::OpenAIContentPart::Text {
                                            text: text.clone(),
                                        },
                                    );
                                }
                                UserContentPart::File { data, media_type } => {
                                    // Determine file type and convert accordingly
                                    if media_type.starts_with("image/") {
                                        match crate::multimodal::convert_image_part(
                                            data, media_type,
                                        ) {
                                            Ok(part) => openai_content.push(part),
                                            Err(e) => {
                                                // Log error but continue
                                                eprintln!(
                                                    "Warning: Failed to convert image: {}",
                                                    e
                                                );
                                            }
                                        }
                                    } else if media_type.starts_with("audio/") {
                                        match crate::multimodal::convert_audio_part(
                                            data, media_type,
                                        ) {
                                            Ok(part) => openai_content.push(part),
                                            Err(e) => {
                                                eprintln!(
                                                    "Warning: Failed to convert audio: {}",
                                                    e
                                                );
                                            }
                                        }
                                    } else {
                                        eprintln!(
                                            "Warning: Unsupported media type: {}",
                                            media_type
                                        );
                                    }
                                }
                            }
                        }

                        openai_messages.push(crate::api_types::ChatMessage {
                            role: "user".into(),
                            content: Some(crate::api_types::ChatMessageContent::Parts(
                                openai_content,
                            )),
                            tool_calls: None,
                            tool_call_id: None,
                            annotations: None,
                        });
                    } else {
                        // Text-only message: join all text parts
                        let text_content = content
                            .iter()
                            .filter_map(|part| match part {
                                UserContentPart::Text { text } => Some(text.clone()),
                                UserContentPart::File { .. } => None,
                            })
                            .collect::<Vec<_>>()
                            .join("\n");

                        openai_messages.push(crate::api_types::ChatMessage {
                            role: "user".into(),
                            content: Some(crate::api_types::ChatMessageContent::Text(text_content)),
                            tool_calls: None,
                            tool_call_id: None,
                            annotations: None,
                        });
                    }
                }
                Message::Assistant { content } => {
                    let mut text_content = String::new();
                    let mut tool_calls = Vec::new();

                    for part in content {
                        match part {
                            AssistantContentPart::Text(text_part) => {
                                text_content.push_str(&text_part.text);
                            }
                            AssistantContentPart::ToolCall(tool_call) => {
                                tool_calls.push(crate::api_types::OpenAIToolCall {
                                    id: tool_call.tool_call_id.clone(),
                                    r#type: "function".to_string(),
                                    function: crate::api_types::OpenAIFunctionCall {
                                        name: tool_call.tool_name.clone(),
                                        arguments: tool_call.input.clone(),
                                    },
                                });
                            }
                            // Skip other content types for now
                            _ => {}
                        }
                    }

                    openai_messages.push(crate::api_types::ChatMessage {
                        role: "assistant".into(),
                        content: if text_content.is_empty() {
                            None
                        } else {
                            Some(crate::api_types::ChatMessageContent::Text(text_content))
                        },
                        tool_calls: if tool_calls.is_empty() {
                            None
                        } else {
                            Some(tool_calls)
                        },
                        tool_call_id: None,
                        annotations: None,
                    });
                }
                Message::Tool { content } => {
                    // Convert tool results to OpenAI tool messages
                    for tool_result in content {
                        openai_messages.push(crate::api_types::ChatMessage {
                            role: "tool".into(),
                            content: Some(crate::api_types::ChatMessageContent::Text(
                                serde_json::to_string(&tool_result.output).unwrap_or_default(),
                            )),
                            tool_calls: None,
                            tool_call_id: Some(tool_result.tool_call_id.clone()),
                            annotations: None,
                        });
                    }
                }
            }
        }

        openai_messages
    }

    fn convert_tools(&self, tools: &[language_model::Tool]) -> Vec<crate::api_types::OpenAITool> {
        tools
            .iter()
            .filter_map(|tool| match tool {
                language_model::Tool::Function(function_tool) => {
                    Some(crate::api_types::OpenAITool {
                        r#type: "function".to_string(),
                        function: crate::api_types::OpenAIFunction {
                            name: function_tool.name.clone(),
                            description: function_tool.description.clone(),
                            parameters: function_tool.input_schema.clone(),
                        },
                    })
                }
                // Skip provider-defined tools for now
                language_model::Tool::ProviderDefined(_) => None,
            })
            .collect()
    }

    fn convert_tool_choice(
        &self,
        tool_choice: &language_model::ToolChoice,
    ) -> crate::api_types::OpenAIToolChoice {
        match tool_choice {
            language_model::ToolChoice::Auto => {
                crate::api_types::OpenAIToolChoice::String("auto".to_string())
            }
            language_model::ToolChoice::None => {
                crate::api_types::OpenAIToolChoice::String("none".to_string())
            }
            language_model::ToolChoice::Required => {
                crate::api_types::OpenAIToolChoice::String("required".to_string())
            }
            language_model::ToolChoice::Tool { tool_name } => {
                crate::api_types::OpenAIToolChoice::Specific {
                    r#type: "function".to_string(),
                    function: crate::api_types::OpenAIFunctionName {
                        name: tool_name.clone(),
                    },
                }
            }
        }
    }

    fn convert_response_format(
        &self,
        response_format: &language_model::ResponseFormat,
    ) -> crate::api_types::OpenAIResponseFormat {
        match response_format {
            language_model::ResponseFormat::Text => crate::api_types::OpenAIResponseFormat::Text,
            language_model::ResponseFormat::Json {
                schema,
                name,
                description,
            } => {
                if let Some(schema) = schema {
                    // Structured output with JSON schema
                    crate::api_types::OpenAIResponseFormat::JsonSchema {
                        json_schema: crate::api_types::OpenAIJsonSchema {
                            name: name.clone().unwrap_or_else(|| "response".to_string()),
                            description: description.clone(),
                            schema: schema.clone(),
                            strict: Some(true), // Enable strict mode for better validation
                        },
                    }
                } else {
                    // Unvalidated JSON mode
                    crate::api_types::OpenAIResponseFormat::JsonObject
                }
            }
        }
    }

    fn map_finish_reason(&self, reason: Option<&str>) -> FinishReason {
        match reason {
            Some("stop") => FinishReason::Stop,
            Some("length") => FinishReason::Length,
            Some("content_filter") => FinishReason::ContentFilter,
            Some("tool_calls") => FinishReason::ToolCalls,
            _ => FinishReason::Unknown,
        }
    }
}

#[async_trait]
impl LanguageModel for OpenAIChatModel {
    fn provider(&self) -> &str {
        "openai"
    }

    fn model_id(&self) -> &str {
        &self.model_id
    }

    async fn supported_urls(&self) -> HashMap<String, Vec<String>> {
        let mut urls = HashMap::new();
        urls.insert("image/*".into(), vec![r"^https?://.*$".into()]);
        urls
    }

    async fn do_generate(&self, options: CallOptions) -> Result<GenerateResponse> {
        // Extract OpenAI-specific options
        let openai_opts = OpenAIChatOptions::from_provider_options(&options.provider_options);

        // Handle temperature for search preview models
        let temperature = if is_search_preview_model(&self.model_id) {
            if options.temperature.is_some() {
                warn!(
                    "Temperature is not supported for search preview model '{}'. Removing temperature setting.",
                    self.model_id
                );
            }
            None
        } else {
            options.temperature
        };

        // Handle max_tokens vs max_completion_tokens for reasoning models
        let (max_tokens, max_completion_tokens) = if is_reasoning_model(&self.model_id) {
            // For reasoning models, use max_completion_tokens instead of max_tokens
            let mct = openai_opts
                .max_completion_tokens
                .or(options.max_output_tokens);
            (None, mct)
        } else {
            (options.max_output_tokens, openai_opts.max_completion_tokens)
        };

        // Validate service_tier for flex processing
        let service_tier = match &openai_opts.service_tier {
            Some(tier) if tier == "flex" && !supports_flex_processing(&self.model_id) => {
                warn!(
                    "Flex processing is not supported for model '{}'. Supported models: o3, o4-mini, gpt-5. Service tier will be ignored.",
                    self.model_id
                );
                None
            }
            tier => tier.clone(),
        };

        let request = crate::api_types::ChatCompletionRequest {
            model: self.model_id.clone(),
            messages: self.convert_prompt_to_messages(&options.prompt),
            temperature,
            max_tokens,
            stream: Some(false),
            tools: options.tools.as_ref().map(|t| self.convert_tools(t)),
            tool_choice: options
                .tool_choice
                .as_ref()
                .map(|tc| self.convert_tool_choice(tc)),
            response_format: options
                .response_format
                .as_ref()
                .map(|rf| self.convert_response_format(rf)),
            stream_options: None, // Not needed for non-streaming

            // OpenAI-specific options
            logit_bias: openai_opts.logit_bias,
            logprobs: openai_opts.logprobs,
            top_logprobs: None, // TODO: Extract from logprobs if it's a number
            user: openai_opts.user,
            parallel_tool_calls: openai_opts.parallel_tool_calls,
            reasoning_effort: openai_opts.reasoning_effort,
            max_completion_tokens,
            store: openai_opts.store,
            metadata: openai_opts.metadata,
            prediction: openai_opts.prediction,
            service_tier,
            verbosity: openai_opts.verbosity,
            prompt_cache_key: openai_opts.prompt_cache_key,
            safety_identifier: openai_opts.safety_identifier,
        };

        // Build request URL using config
        let url = (self.config.url)(OpenAIUrlOptions {
            model_id: self.model_id.clone(),
            path: "/chat/completions".to_string(),
        });

        // Build request with merged headers
        let response = self
            .client
            .post(url)
            .header("Content-Type", "application/json")
            .headers(merge_headers_reqwest(
                (self.config.headers)(),
                options.headers.as_ref(),
            ))
            .json(&request)
            .send()
            .await?;

        if !response.status().is_success() {
            let status_code = response.status().as_u16();
            let message = response.text().await.unwrap();
            return Err(crate::error::OpenAIError::ApiError {
                message,
                status_code: Some(status_code),
            }
            .into());
        }

        // Capture headers before consuming response
        let headers: HashMap<String, String> = response
            .headers()
            .iter()
            .map(|(k, v)| (k.as_str().to_string(), v.to_str().unwrap_or("").to_string()))
            .collect();

        let api_response: crate::api_types::ChatCompletionResponse = response.json().await?;

        let choice = &api_response.choices[0];

        // Build content from the response
        let mut content = Vec::new();

        // Add text content if present
        if let Some(message_content) = &choice.message.content {
            // Extract text from ChatMessageContent
            let text = match message_content {
                crate::api_types::ChatMessageContent::Text(s) => s.clone(),
                crate::api_types::ChatMessageContent::Parts(parts) => {
                    // Join text parts if we somehow get a multi-part response
                    parts
                        .iter()
                        .filter_map(|part| match part {
                            crate::multimodal::OpenAIContentPart::Text { text } => {
                                Some(text.clone())
                            }
                            _ => None,
                        })
                        .collect::<Vec<_>>()
                        .join("\n")
                }
            };

            if !text.is_empty() {
                content.push(Content::Text(TextPart {
                    text,
                    provider_metadata: None,
                }));
            }
        }

        // Add tool calls if present
        if let Some(tool_calls) = &choice.message.tool_calls {
            for tool_call in tool_calls {
                content.push(Content::ToolCall(ToolCallPart {
                    tool_call_id: tool_call.id.clone(),
                    tool_name: tool_call.function.name.clone(),
                    input: tool_call.function.arguments.clone(),
                    provider_executed: None,
                    dynamic: None,
                    provider_metadata: None,
                }));
            }
        }

        // Add annotations/citations as Source content
        if let Some(annotations) = &choice.message.annotations {
            for annotation in annotations {
                content.push(Content::Source(SourcePart {
                    id: generate_source_id(),
                    source_type: SourceType::Url,
                    url: Some(annotation.url.clone()),
                    title: Some(annotation.title.clone()),
                    provider_metadata: None,
                }));
            }
        }

        let usage = api_response
            .usage
            .as_ref()
            .map(|u| Usage {
                input_tokens: Some(u.prompt_tokens),
                output_tokens: u.completion_tokens,
                total_tokens: Some(u.total_tokens),
                reasoning_tokens: u
                    .completion_tokens_details
                    .as_ref()
                    .and_then(|d| d.reasoning_tokens),
                cached_input_tokens: u
                    .prompt_tokens_details
                    .as_ref()
                    .and_then(|d| d.cached_tokens),
            })
            .unwrap_or_default();

        // Set finish reason based on whether tool calls were made
        let finish_reason = if choice.message.tool_calls.is_some() {
            FinishReason::ToolCalls
        } else {
            self.map_finish_reason(choice.finish_reason.as_deref())
        };

        // Build provider metadata with logprobs and prediction tokens if present
        let provider_metadata = {
            let mut openai_metadata: HashMap<String, ai_sdk_provider::json_value::JsonValue> =
                HashMap::new();

            // Add logprobs if present
            if let Some(logprobs) = &choice.logprobs {
                if let Some(content_logprobs) = logprobs.get("content") {
                    let json_value: ai_sdk_provider::json_value::JsonValue =
                        serde_json::from_value(content_logprobs.clone())
                            .unwrap_or(ai_sdk_provider::json_value::JsonValue::Null);
                    openai_metadata.insert("logprobs".to_string(), json_value);
                }
            }

            // Add prediction tokens if present
            if let Some(usage_info) = &api_response.usage {
                if let Some(details) = &usage_info.completion_tokens_details {
                    if let Some(accepted) = details.accepted_prediction_tokens {
                        openai_metadata.insert(
                            "acceptedPredictionTokens".to_string(),
                            ai_sdk_provider::json_value::JsonValue::Number(accepted.into()),
                        );
                    }
                    if let Some(rejected) = details.rejected_prediction_tokens {
                        openai_metadata.insert(
                            "rejectedPredictionTokens".to_string(),
                            ai_sdk_provider::json_value::JsonValue::Number(rejected.into()),
                        );
                    }
                }
            }

            if openai_metadata.is_empty() {
                None
            } else {
                let mut metadata = HashMap::new();
                metadata.insert("openai".to_string(), openai_metadata);
                Some(metadata)
            }
        };

        // Build response info
        let response_info = Some(ResponseInfo {
            headers: Some(headers),
            body: Some(serde_json::to_value(&api_response).unwrap_or(serde_json::json!({}))),
            id: Some(api_response.id.clone()),
            timestamp: Some({
                // Convert Unix timestamp to ISO 8601
                let secs = api_response.created as i64;
                let hours = secs / 3600;
                let minutes = (secs % 3600) / 60;
                let seconds = secs % 60;
                format!("1970-01-01T{:02}:{:02}:{:02}Z", hours, minutes, seconds)
            }),
            model_id: Some(api_response.model.clone()),
        });

        Ok(GenerateResponse {
            content,
            finish_reason,
            usage,
            provider_metadata,
            request: None,
            response: response_info,
            warnings: vec![],
        })
    }

    async fn do_stream(&self, options: CallOptions) -> Result<StreamResponse> {
        // Extract OpenAI-specific options
        let openai_opts = OpenAIChatOptions::from_provider_options(&options.provider_options);

        // Handle temperature for search preview models
        let temperature = if is_search_preview_model(&self.model_id) {
            if options.temperature.is_some() {
                warn!(
                    "Temperature is not supported for search preview model '{}'. Removing temperature setting.",
                    self.model_id
                );
            }
            None
        } else {
            options.temperature
        };

        // Handle max_tokens vs max_completion_tokens for reasoning models
        let (max_tokens, max_completion_tokens) = if is_reasoning_model(&self.model_id) {
            // For reasoning models, use max_completion_tokens instead of max_tokens
            let mct = openai_opts
                .max_completion_tokens
                .or(options.max_output_tokens);
            (None, mct)
        } else {
            (options.max_output_tokens, openai_opts.max_completion_tokens)
        };

        // Validate service_tier for flex processing
        let service_tier = match &openai_opts.service_tier {
            Some(tier) if tier == "flex" && !supports_flex_processing(&self.model_id) => {
                warn!(
                    "Flex processing is not supported for model '{}'. Supported models: o3, o4-mini, gpt-5. Service tier will be ignored.",
                    self.model_id
                );
                None
            }
            tier => tier.clone(),
        };

        let request = crate::api_types::ChatCompletionRequest {
            model: self.model_id.clone(),
            messages: self.convert_prompt_to_messages(&options.prompt),
            temperature,
            max_tokens,
            stream: Some(true),
            tools: options.tools.as_ref().map(|t| self.convert_tools(t)),
            tool_choice: options
                .tool_choice
                .as_ref()
                .map(|tc| self.convert_tool_choice(tc)),
            response_format: options
                .response_format
                .as_ref()
                .map(|rf| self.convert_response_format(rf)),
            stream_options: Some(crate::api_types::StreamOptions {
                include_usage: true,
            }),

            // OpenAI-specific options
            logit_bias: openai_opts.logit_bias,
            logprobs: openai_opts.logprobs,
            top_logprobs: None,
            user: openai_opts.user,
            parallel_tool_calls: openai_opts.parallel_tool_calls,
            reasoning_effort: openai_opts.reasoning_effort,
            max_completion_tokens,
            store: openai_opts.store,
            metadata: openai_opts.metadata,
            prediction: openai_opts.prediction,
            service_tier,
            verbosity: openai_opts.verbosity,
            prompt_cache_key: openai_opts.prompt_cache_key,
            safety_identifier: openai_opts.safety_identifier,
        };

        // Build request URL using config
        let url = (self.config.url)(OpenAIUrlOptions {
            model_id: self.model_id.clone(),
            path: "/chat/completions".to_string(),
        });

        // Build request with merged headers
        let response = self
            .client
            .post(url)
            .header("Content-Type", "application/json")
            .headers(merge_headers_reqwest(
                (self.config.headers)(),
                options.headers.as_ref(),
            ))
            .json(&request)
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            return Err(crate::error::OpenAIError::ApiError {
                message: format!("API returned status {}", status),
                status_code: Some(status.as_u16()),
            }
            .into());
        }

        let stream_impl = stream! {
            let mut byte_stream = response.bytes_stream();
            let mut buffer = String::new();
            let mut tool_calls: Vec<crate::api_types::OpenAIToolCall> = Vec::new();
            let mut accumulated_usage: Option<Usage> = None;
            let mut last_finish_reason: Option<FinishReason> = None;

            while let Some(chunk_result) = byte_stream.next().await {
                match chunk_result {
                    Ok(bytes) => {
                        buffer.push_str(&String::from_utf8_lossy(&bytes));

                        // Process SSE lines
                        while let Some(line_end) = buffer.find('\n') {
                            let line = buffer[..line_end].trim().to_string();
                            buffer.drain(..line_end + 1);

                            if let Some(data) = line.strip_prefix("data: ") {
                                if data == "[DONE]" {
                                    break;
                                }

                                // Parse JSON chunk and convert to StreamPart
                                if let Ok(chunk) = serde_json::from_str::<crate::api_types::ChatCompletionChunk>(data) {
                                    // Capture usage if present
                                    if let Some(usage_info) = &chunk.usage {
                                        accumulated_usage = Some(Usage {
                                            input_tokens: Some(usage_info.prompt_tokens),
                                            output_tokens: usage_info.completion_tokens,
                                            total_tokens: Some(usage_info.total_tokens),
                                            reasoning_tokens: usage_info
                                                .completion_tokens_details
                                                .as_ref()
                                                .and_then(|d| d.reasoning_tokens),
                                            cached_input_tokens: usage_info
                                                .prompt_tokens_details
                                                .as_ref()
                                                .and_then(|d| d.cached_tokens),
                                        });
                                    }

                                    // Convert OpenAI chunk to our StreamPart
                                    if let Some(choice) = chunk.choices.first() {
                                        // Handle text content
                                        if let Some(content) = &choice.delta.content {
                                            yield Ok(StreamPart::TextDelta {
                                                id: "0".into(),
                                                delta: content.clone(),
                                                provider_metadata: None,
                                            });
                                        }

                                        // Handle tool call deltas
                                        if let Some(tool_call_deltas) = &choice.delta.tool_calls {
                                            for tool_call_delta in tool_call_deltas {
                                                let index = tool_call_delta.index as usize;

                                                // Initialize new tool call if needed
                                                if tool_calls.len() <= index {
                                                    let tool_id = tool_call_delta.id.clone().unwrap_or_default();
                                                    let tool_name = tool_call_delta.function.name.clone().unwrap_or_default();

                                                    tool_calls.push(crate::api_types::OpenAIToolCall {
                                                        id: tool_id.clone(),
                                                        r#type: "function".to_string(),
                                                        function: crate::api_types::OpenAIFunctionCall {
                                                            name: tool_name.clone(),
                                                            arguments: String::new(),
                                                        },
                                                    });

                                                    // Emit ToolInputStart
                                                    yield Ok(StreamPart::ToolInputStart {
                                                        id: tool_id,
                                                        tool_name,
                                                        provider_metadata: None,
                                                        provider_executed: None,
                                                        dynamic: None,
                                                        title: None,
                                                    });
                                                }

                                                // Accumulate arguments
                                                if let Some(args_delta) = &tool_call_delta.function.arguments {
                                                    tool_calls[index].function.arguments.push_str(args_delta);

                                                    // Emit ToolInputDelta
                                                    yield Ok(StreamPart::ToolInputDelta {
                                                        id: tool_calls[index].id.clone(),
                                                        delta: args_delta.clone(),
                                                        provider_metadata: None,
                                                    });
                                                }
                                            }
                                        }

                                        // Handle streaming annotations
                                        if let Some(annotations) = &choice.delta.annotations {
                                            for annotation in annotations {
                                                yield Ok(StreamPart::Source(SourcePart {
                                                    id: generate_source_id(),
                                                    source_type: SourceType::Url,
                                                    url: Some(annotation.url.clone()),
                                                    title: Some(annotation.title.clone()),
                                                    provider_metadata: None,
                                                }));
                                            }
                                        }

                                        // Handle finish reason
                                        if let Some(finish_reason) = &choice.finish_reason {
                                            if !finish_reason.is_empty() && finish_reason != "null" {
                                                // Emit ToolInputEnd and ToolCall for each complete tool
                                                for tool_call in &tool_calls {
                                                    yield Ok(StreamPart::ToolInputEnd {
                                                        id: tool_call.id.clone(),
                                                        provider_metadata: None,
                                                    });

                                                    yield Ok(StreamPart::ToolCall(ToolCallPart {
                                                        tool_call_id: tool_call.id.clone(),
                                                        tool_name: tool_call.function.name.clone(),
                                                        input: tool_call.function.arguments.clone(),
                                                        provider_executed: None,
                                                        dynamic: None,
                                                        provider_metadata: None,
                                                    }));
                                                }

                                                let mapped_reason = match finish_reason.as_str() {
                                                    "stop" => FinishReason::Stop,
                                                    "length" => FinishReason::Length,
                                                    "content_filter" => FinishReason::ContentFilter,
                                                    "tool_calls" => FinishReason::ToolCalls,
                                                    _ => FinishReason::Unknown,
                                                };

                                                // Store the finish reason but don't emit Finish yet
                                                // OpenAI may send usage in a subsequent chunk
                                                last_finish_reason = Some(mapped_reason);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    Err(e) => {
                        yield Err(OpenAIError::NetworkError(e).into());
                        break;
                    }
                }
            }

            // Emit Finish event with accumulated usage
            // OpenAI sends usage in a separate chunk after finish_reason when stream_options.include_usage is true
            if let Some(finish_reason) = last_finish_reason {
                let usage_to_send = accumulated_usage.unwrap_or_default();
                yield Ok(StreamPart::Finish {
                    usage: usage_to_send,
                    finish_reason,
                    provider_metadata: None,
                });
            }
        };

        Ok(StreamResponse {
            stream: Box::pin(stream_impl),
            request: None,
            response: None,
        })
    }
}