open_ai/resources/chat/

completions.rs

use crate::core::streaming::APIFuture;
use crate::core::RequestOptions;
use crate::resource::APIResource;
use crate::resources::completions as completion_api;
use crate::shared;
use crate::{OpenAI, OpenAIObject};
use futures::executor::block_on;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::cell::RefCell;
use std::collections::HashMap;
use std::error::Error;
use std::rc::Rc;

#[derive(Debug, Clone)]
pub struct Completions {
    pub client: Option<APIResource>,
}

impl Completions {
    pub fn new() -> Self {
        Completions { client: None }
    }

    /// Creates a model response for the given chat conversation.
    pub fn create<'a>(
        &'a self,
        body: ChatCompletionCreateParams<'a>,
    ) -> APIFuture<ChatCompletionCreateParams, ChatCompletion, ChatCompletionChunk> {
        let stream = body.stream.unwrap_or(false);
        self.client.clone().unwrap().clone().lock().unwrap().post(
            "/chat/completions",
            Some(RequestOptions {
                body: Some(body),
                stream: Some(stream),
                ..Default::default()
            }),
        )
    }
}

/// Represents a chat completion response returned by model, based on the provided
/// input.
#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletion {
    /// A unique identifier for the chat completion.
    pub id: String,

    /// A list of chat completion choices. Can be more than one if `n` is greater
    /// than 1.
    pub choices: Vec<chat_completion::Choice>,

    /// The Unix timestamp (in seconds) of when the chat completion was created.
    pub created: u64,

    /// The model used for the chat completion.
    pub model: String,

    /// The object type, which is always `chat.completion`.
    pub object: OpenAIObject,

    /// The service tier used for processing the request. This field is only included if
    /// the `service_tier` parameter is specified in the request.
    pub service_tier: Option<ServiceTier>,

    /// This fingerprint represents the backend configuration that the model runs with.
    ///
    /// Can be used in conjunction with the `seed` request parameter to understand when
    /// backend changes have been made that might impact determinism.
    pub system_fingerprint: Option<String>,

    /// Usage statistics for the completion request.
    pub usage: Option<completion_api::CompletionUsage>,
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FinishReason {
    #[default]
    Stop,
    Length,
    ToolCalls,
    ContentFilter,
    FunctionCall,
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChatCompletionRole {
    #[default]
    Assistant,
    User,
    System,
    Tool,
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ServiceTier {
    #[default]
    Default,
    Scale,
}

pub mod chat_completion {
    use super::*;

    /// Represents a chat completion choice.
    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct Choice {
        /// The reason the model stopped generating tokens. This will be `stop` if the model
        /// hit a natural stop point or a provided stop sequence, `length` if the maximum
        /// number of tokens specified in the request was reached, `content_filter` if
        /// content was omitted due to a flag from our content filters, `tool_calls` if the
        /// model called a tool, or `function_call` (deprecated) if the model called a
        /// function.
        pub finish_reason: FinishReason,

        /// The index of the choice in the list of choices.
        pub index: u32,

        /// Log probability information for the choice.
        pub logprobs: Option<choice::Logprobs>,

        /// A chat completion message generated by the model.
        pub message: ChatCompletionMessage,
    }
}

pub mod choice {
    use super::*;

    /// Log probability information for the choice.
    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct Logprobs {
        /// A list of message content tokens with log probability information.
        pub content: Option<Vec<ChatCompletionTokenLogprob>>,
        //  content: Option<Vec<ChatCompletionsAPI.ChatCompletionTokenLogprob> | null;
    }
}

#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionAssistantMessageParam {
    /// The role of the messages author, in this case `assistant`.
    pub role: String, // 'assistant'

    /// The contents of the assistant message. Required unless `tool_calls` or
    /// `function_call` is specified.
    pub content: Option<String>,

    /// An optional name for the participant. Provides the model information to
    /// differentiate between participants of the same role.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,

    /// The tool calls generated by the model, such as function calls.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<ChatCompletionMessageToolCall>>,

    #[deprecated(
        note = "Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be called, as generated by the model."
    )]
    pub function_call: Option<chat_completion_assistant_message_param::FunctionCall>,
}

pub mod chat_completion_assistant_message_param {
    use super::*;

    #[deprecated(
        note = "Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be called, as generated by the model."
    )]
    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct FunctionCall {
        /// The arguments to call the function with, as generated by the model in JSON
        /// format. Note that the model does not always generate valid JSON, and may
        /// hallucinate parameters not defined by your function schema. Validate the
        /// arguments in your code before calling your function.
        pub arguments: String,

        /// The name of the function to call.
        pub name: String,
    }
}

/// Represents a streamed chunk of a chat completion response returned by model,
/// based on the provided input.
#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionChunk {
    /// A unique identifier for the chat completion. Each chunk has the same ID.
    pub id: String,

    /// A list of chat completion choices. Can contain more than one elements if `n` is
    /// greater than 1. Can also be empty for the last chunk if you set
    /// `stream_options: {"include_usage": true}`.
    pub choices: Vec<chat_completion_chunk::Choice>,

    /// The Unix timestamp (in seconds) of when the chat completion was created. Each
    /// chunk has the same timestamp.
    pub created: u64,

    /// The model to generate the completion.
    pub model: String,

    /// The object type, which is always `chat.completion.chunk`.
    pub object: String, // "chat.completion.chunk"

    /// The service tier used for processing the request. This field is only included if
    /// the `service_tier` parameter is specified in the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<ServiceTier>,

    /// This fingerprint represents the backend configuration that the model runs with.
    /// Can be used in conjunction with the `seed` request parameter to understand when
    /// backend changes have been made that might impact determinism.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system_fingerprint: Option<String>,

    /// An optional field that will only be present when you set
    /// `stream_options: {"include_usage": true}` in your request. When present, it
    /// contains a null value except for the last chunk which contains the token usage
    /// statistics for the entire request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub usage: Option<completion_api::CompletionUsage>,
}

// struct Chunk {
//     id: "chatcmpl-9quHjsUbwM6nAuNFEkx3WqxstvTxK",
//     object: "chat.completion.chunk",
//     created: 1722396443,
//     model: "gpt-4o-mini-2024-07-18",
//     system_fingerprint: "fp_0f03d4f0ee",
//     choices: [
//         {
//             index: 0,
//             delta: {
//                 role: "assistant",
//                 content: ""
//             },
//             logprobs: null,
//             finish_reason: null
//         }
//     ]
// }

pub mod chat_completion_chunk {
    use super::*;

    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct Choice {
        /// A chat completion delta generated by streamed model responses.
        pub delta: choice::Delta,

        /// The reason the model stopped generating tokens. This will be `stop` if the model
        /// hit a natural stop point or a provided stop sequence, `length` if the maximum
        /// number of tokens specified in the request was reached, `content_filter` if
        /// content was omitted due to a flag from our content filters, `tool_calls` if the
        /// model called a tool, or `function_call` (deprecated) if the model called a
        /// function.
        pub finish_reason: Option<FinishReason>,

        /// The index of the choice in the list of choices.
        pub index: u32,

        /// Log probability information for the choice.
        #[serde(skip_serializing_if = "Option::is_none")]
        pub logprobs: Option<choice::Logprobs>,
    }

    pub mod choice {
        use super::*;

        /// A chat completion delta generated by streamed model responses.
        #[derive(Default, Debug, Clone, Deserialize, Serialize)]
        pub struct Delta {
            /// The contents of the chunk message.
            #[serde(skip_serializing_if = "Option::is_none")]
            pub content: Option<String>,

            /// @deprecated: Deprecated and replaced by `tool_calls`. The name and arguments of
            /// a function that should be called, as generated by the model.
            #[serde(skip_serializing_if = "Option::is_none")]
            pub function_call: Option<delta::FunctionCall>,

            /// The role of the author of this message.
            #[serde(skip_serializing_if = "Option::is_none")]
            pub role: Option<ChatCompletionRole>,

            #[serde(skip_serializing_if = "Option::is_none")]
            pub tool_calls: Option<Vec<delta::ToolCall>>,
        }

        pub mod delta {
            use super::*;

            /// @deprecated: Deprecated and replaced by `tool_calls`. The name and arguments of
            /// a function that should be called, as generated by the model.
            #[derive(Default, Debug, Clone, Deserialize, Serialize)]
            pub struct FunctionCall {
                /// The arguments to call the function with, as generated by the model in JSON
                /// format. Note that the model does not always generate valid JSON, and may
                /// hallucinate parameters not defined by your function schema. Validate the
                /// arguments in your code before calling your function.
                #[serde(skip_serializing_if = "Option::is_none")]
                pub arguments: Option<String>,

                /// The name of the function to call.
                #[serde(skip_serializing_if = "Option::is_none")]
                pub name: Option<String>,
            }

            #[derive(Default, Debug, Clone, Deserialize, Serialize)]
            pub struct ToolCall {
                pub index: u32,

                /// The ID of the tool call.
                #[serde(skip_serializing_if = "Option::is_none")]
                pub id: Option<String>,

                #[serde(skip_serializing_if = "Option::is_none")]
                pub function: Option<tool_call::Function>,

                /// The type of the tool. Currently, only `function` is supported.
                #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
                pub tool_call_type: Option<String>, // "function"
            }

            pub mod tool_call {
                use super::*;

                #[derive(Default, Debug, Clone, Deserialize, Serialize)]
                pub struct Function {
                    /// The arguments to call the function with, as generated by the model in JSON
                    /// format. Note that the model does not always generate valid JSON, and may
                    /// hallucinate parameters not defined by your function schema. Validate the
                    /// arguments in your code before calling your function.
                    #[serde(skip_serializing_if = "Option::is_none")]
                    pub arguments: Option<String>,

                    /// The name of the function to call.
                    #[serde(skip_serializing_if = "Option::is_none")]
                    pub name: Option<String>,
                }
            }
        }

        /// Log probability information for the choice.
        #[derive(Default, Debug, Clone, Deserialize, Serialize)]
        pub struct Logprobs {
            /// A list of message content tokens with log probability information.
            pub content: Option<Vec<ChatCompletionTokenLogprob>>, // null
        }
    }
}

// export type ChatCompletionContentPart = ChatCompletionContentPartText | ChatCompletionContentPartImage;
// export type ChatCompletionContentPart = ChatCompletionContentPartText | ChatCompletionContentPartImage;

// #[derive(Debug, Clone, Serialize, Deserialize)]
// #[serde(untagged)]
// pub enum ChatCompletionContentPart {
//     Text(ChatCompletionContentPartText),
//     Image(ChatCompletionContentPartImage),
// }
//
// impl Default for ChatCompletionContentPart {
//     fn default() -> Self {
//         ChatCompletionContentPart::Text(Default::default())
//     }
// }
//
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ChatCompletionContent<'a> {
    Text(&'a str),
    Multiple(Vec<ChatCompletionContentPart<'a>>),
}

impl<'a> Default for ChatCompletionContent<'a> {
    fn default() -> Self {
        ChatCompletionContent::Text(Default::default())
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ChatCompletionContentPart<'a> {
    Text {
        text: &'a str,
    },
    #[serde(rename = "image_url")]
    Image {
        image_url: chat_completion_content_part_image::ImageURL<'a>,
    },
}

impl<'a> Default for ChatCompletionContentPart<'a> {
    fn default() -> Self {
        ChatCompletionContentPart::Text { text: "" }
    }
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(bound(deserialize = "'de: 'a"))]
pub struct ChatCompletionContentPartImage<'a> {
    pub image_url: chat_completion_content_part_image::ImageURL<'a>,

    /// The type of the content part.
    #[serde(rename = "type")]
    pub content_type: String, // 'image_url',
}

pub mod chat_completion_content_part_image {
    use super::*;

    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct ImageURL<'a> {
        /// Either a URL of the image or the base64 encoded image data.
        pub url: &'a str,

        /// Specifies the detail level of the image. Learn more in the
        /// [Vision guide](https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding).
        #[serde(skip_serializing_if = "Option::is_none")]
        pub detail: Option<Detail>,
    }

    #[derive(Default, Debug, Clone, Serialize, Deserialize)]
    #[serde(rename_all = "snake_case")]
    pub enum Detail {
        #[default]
        Auto,
        Low,
        High,
    }
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct ChatCompletionContentPartText {
    /// The text content.
    text: String,

    /// The type of the content part.
    content_type: String, // 'text',
}

/// Specifying a particular function via `{"name": "my_function"}` forces the model
/// to call that function.
pub struct ChatCompletionFunctionCallOption {
    /// The name of the function to call.
    pub name: String,
}

#[deprecated()]
pub struct ChatCompletionFunctionMessageParam {
    /// The contents of the function message.
    content: Option<String>,

    /// The name of the function to call.
    name: String,

    /// The role of the messages author, in this case `function`.
    role: String, // "function"
}

/// A chat completion message generated by the model.
#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionMessage {
    /// The contents of the message.
    pub content: Option<String>,

    /// The role of the author of this message.
    pub role: String, // 'assistant',

    /// The name and arguments ofpub a function that should be called, as generated by the model,
    #[deprecated(
        note = "Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be called, as generated by the model."
    )]
    pub function_call: Option<chat_completion_message::FunctionCall>,

    /// The tool calls generated by the model, such as function calls.
    pub tool_calls: Option<Vec<ChatCompletionMessageToolCall>>,
}

pub mod chat_completion_message {
    use super::*;

    #[deprecated(
        note = "Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be called, as generated by the model."
    )]
    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct FunctionCall {
        /// The arguments to call the function with, as generated by the model in JSON
        /// format. Note that the model does not always generate valid JSON, and may
        /// hallucinate parameters not defined by your function schema. Validate the
        /// arguments in your code before calling your function.
        pub arguments: String,

        /// The name of the function to call.
        pub name: String,
    }
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(tag = "role", rename_all = "snake_case")]
pub enum ChatCompletionMessageParam<'a> {
    Assistant {
        /// The contents of the assistant message. Required unless `tool_calls` or
        /// `function_call` is specified.
        #[serde(skip_serializing_if = "Option::is_none")]
        content: Option<&'a str>,

        /// An optional name for the participant. Provides the model information to
        /// differentiate between participants of the same role.
        #[serde(skip_serializing_if = "Option::is_none")]
        name: Option<&'a str>,

        /// The tool calls generated by the model, such as function calls.
        #[serde(skip_serializing_if = "Option::is_none")]
        tool_calls: Option<Vec<ChatCompletionMessageToolCall>>,
    },
    User {
        /// The contents of the user message.
        content: ChatCompletionContent<'a>,

        /// An optional name for the participant. Provides the model information to
        /// differentiate between participants of the same role.
        #[serde(skip_serializing_if = "Option::is_none")]
        name: Option<&'a str>,
    },
    System {
        /// The contents of the system message.
        content: &'a str,

        /// An optional name for the participant. Provides the model information to
        /// differentiate between participants of the same role.
        #[serde(skip_serializing_if = "Option::is_none")]
        name: Option<&'a str>,
    },
    Tool {
        /// The contents of the tool message.
        content: &'a str,

        /// Tool call that this message is responding to.
        tool_call_id: &'a str,
    },
}

impl<'a> Default for ChatCompletionMessageParam<'a> {
    fn default() -> Self {
        ChatCompletionMessageParam::Assistant {
            content: None,
            name: None,
            tool_calls: None,
        }
    }
}

// #[derive(Default, Debug, Clone, Deserialize, Serialize)]
// pub struct ChatCompletionSystemParam {
//     /// The contents of the system message.
//     pub content: String,
//
//     /// An optional name for the participant. Provides the model information to
//     /// differentiate between participants of the same role.
//     #[serde(skip_serializing_if = "Option::is_none")]
//     pub name: Option<String>,
// }

// #[derive(Default, Debug, Clone, Serialize, Deserialize)]
// pub struct ChatCompletionUserParam {
//     /// The contents of the user message.
//     pub content: ChatCompletionContent,
//
//     /// An optional name for the participant. Provides the model information to
//     /// differentiate between participants of the same role.
//     #[serde(skip_serializing_if = "Option::is_none")]
//     pub name: Option<String>,
// }

// #[derive(Default, Debug, Clone, Deserialize, Serialize)]
// pub struct ChatCompletionAssistantParam {
//     /// The contents of the assistant message. Required unless `tool_calls` or
//     /// `function_call` is specified.
//     #[serde(skip_serializing_if = "Option::is_none")]
//     pub content: Option<String>,
//
//     /// An optional name for the participant. Provides the model information to
//     /// differentiate between participants of the same role.
//     #[serde(skip_serializing_if = "Option::is_none")]
//     pub name: Option<String>,
//
//     /// The tool calls generated by the model, such as function calls.
//     #[serde(skip_serializing_if = "Option::is_none")]
//     pub tool_calls: Option<Vec<ChatCompletionMessageToolCall>>,
// }

// #[derive(Default, Debug, Clone, Deserialize, Serialize)]
// pub struct ChatCompletionToolParam {
//     /// The contents of the tool message.
//     pub content: String,
//
//     /// Tool call that this message is responding to.
//     pub tool_call_id: String,
// }

#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionMessageToolCall {
    /// The ID of the tool call.
    pub id: String,

    /// The function that the model called.
    pub function: chat_completion_message_tool_call::Function,

    /// The type of the tool. Currently, only `function` is supported.
    #[serde(rename = "type")]
    pub tool_call_type: String,
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChatCompletionMessageToolCallType {
    #[default]
    Function,
}

mod chat_completion_message_tool_call {
    use super::*;
    /// The function that the model called.
    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct Function {
        /// The arguments to call the function with, as generated by the model in JSON
        /// format. Note that the model does not always generate valid JSON, and may
        /// hallucinate parameters not defined by your function schema. Validate the
        /// arguments in your code before calling your function.
        pub arguments: String,

        /// The name of the function to call.
        pub name: String,
    }
}

/// Specifies a tool the model should use. Use to force the model to call a specific
/// function.
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct ChatCompletionNamedToolChoice {
    pub function: chat_completion_named_tool_choice::Function,

    /// The type of the tool. Currently, only `function` is supported.
    #[serde(rename = "type")]
    tool_choice_type: ChatCompletionNamedToolChoiceType,
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChatCompletionNamedToolChoiceType {
    #[default]
    Function,
}

pub mod chat_completion_named_tool_choice {
    use super::*;

    #[derive(Default, Debug, Clone, Serialize, Deserialize)]
    pub struct Function {
        /// The name of the function to call.
        name: String,
    }
}

/// The role of the author of a message
// export type ChatCompletionRole = 'system' | 'user' | 'assistant' | 'tool' | 'function';

/// Options for streaming response. Only set this when you set `stream: true`.
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct ChatCompletionStreamOptions {
    /// If set, an additional chunk will be streamed before the `data: [DONE]` message.
    /// The `usage` field on this chunk shows the token usage statistics for the entire
    /// request, and the `choices` field will always be an empty array. All other chunks
    /// will also include a `usage` field, but with a null value.
    pub include_usage: Option<bool>,
}

#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionSystemMessageParam {
    /// The contents of the system message.
    pub content: String,

    /// The role of the messages author, in this case `system`.
    pub role: String, // 'system',

    /// An optional name for the participant. Provides the model information to
    /// differentiate between participants of the same role.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionTokenLogprob {
    /// The token.
    pub token: String,

    /// A list of integers representing the UTF-8 bytes representation of the token.
    /// Useful in instances where characters are represented by multiple tokens and
    /// their byte representations must be combined to generate the correct text
    /// representation. Can be `null` if there is no bytes representation for the token.
    pub bytes: Option<Vec<u8>>,

    /// The log probability of this token, if it is within the top 20 most likely
    /// tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
    /// unlikely.
    pub logprob: f32,

    /// List of the most likely tokens and their log probability, at this token
    /// position. In rare cases, there may be fewer than the number of requested
    /// `top_logprobs` returned.
    pub top_logprobs: Vec<chat_completion_token_logprob::TopLogprob>,
}

pub mod chat_completion_token_logprob {
    use super::*;

    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    pub struct TopLogprob {
        /// The token.
        token: String,

        /// A list of integers representing the UTF-8 bytes representation of the token.
        /// Useful in instances where characters are represented by multiple tokens and
        /// their byte representations must be combined to generate the correct text
        /// representation. Can be `null` if there is no bytes representation for the token.
        pub bytes: Option<Vec<u8>>,

        /// The log probability of this token, if it is within the top 20 most likely
        /// tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
        /// unlikely.
        pub logprob: f32,
    }
}

#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionTool {
    pub function: shared::FunctionDefinition,

    /// The type of the tool. Currently, only `function` is supported.
    pub tool_type: String, // "function"
}

/// Controls which (if any) tool is called by the model. `none` means the model will
/// not call any tool and instead generates a message. `auto` means the model can
/// pick between generating a message or calling one or more tools. `required` means
/// the model must call one or more tools. Specifying a particular tool via
/// `{"type": "function", "function": {"name": "my_function"}}` forces the model to
/// call that tool.
///
/// `none` is the default when no tools are present. `auto` is the default if tools
/// are present.
///
pub type ChatCompletionToolChoiceOption = String;
// pub type ChatCompletionToolChoiceOption = "none" | "auto" | "required" | ChatCompletionNamedToolChoice;

pub struct ChatCompletionToolMessageParam {
    /// The contents of the tool message.
    pub content: String,

    /// The role of the messages author, in this case `tool`.
    pub role: String, // "tool"

    /// Tool call that this message is responding to.
    pub tool_call_id: String,
}

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct ChatCompletionUserMessageParam {
    /// The contents of the user message.
    pub content: String, // | Vec<ChatCompletionContentPart>,

    /// The role of the messages author, in this case `user`.
    pub role: String, // "user"

    /// An optional name for the participant. Provides the model information to
    /// differentiate between participants of the same role.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

// /// @deprecated ChatCompletionMessageParam should be used instead
// export type CreateChatCompletionRequestMessage = ChatCompletionMessageParam;
//
// export type ChatCompletionCreateParams =
//   | ChatCompletionCreateParamsNonStreaming
//   | ChatCompletionCreateParamsStreaming;

#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionCreateParams<'a> {
    /// A list of messages comprising the conversation so far.
    /// [Example Python code](https://cookbook.openai.com/examples/how_to_format_inputs_to_chatgpt_models).
    /// pub enum ChatCompletionMessageParam {
    ///
    ///
    pub messages: Vec<ChatCompletionMessageParam<'a>>,

    /// ID of the model to use. See the
    /// [model endpoint compatibility](https://platform.openai.com/docs/models/model-endpoint-compatibility)
    /// table for details on which models work with the Chat API.
    pub model: &'a str, // (string & {}) | ChatAPI.ChatModel,

    /// Number between -2.0 and 2.0. Positive values penalize new tokens based on their
    /// existing frequency in the text so far, decreasing the model's likelihood to
    /// repeat the same line verbatim.
    ///
    /// [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation/parameter-details)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub frequency_penalty: Option<f32>,

    /// Deprecated in favor of `tool_choice`.
    ///
    /// Controls which (if any) function is called by the model. `none` means the model
    /// will not call a function and instead generates a message. `auto` means the model
    /// can pick between generating a message or calling a function. Specifying a
    /// particular function via `{"name": "my_function"}` forces the model to call that
    /// function.
    ///
    /// `none` is the default when no functions are present. `auto` is the default if
    /// functions are present.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub function_call: Option<String>,
    // !TODO create an enum
    // pub function_call: Option<"none" | "auto" | ChatCompletionFunctionCallOption>,
    /// Deprecated in favor of `tools`.
    ///
    /// A list of functions the model may generate JSON inputs for.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub functions: Option<Vec<chat_completion_create_params::Function>>,

    /// Modify the likelihood of specified tokens appearing in the completion.
    ///
    /// Accepts a JSON object that maps tokens (specified by their token ID in the
    /// tokenizer) to an associated bias value from -100 to 100. Mathematically, the
    /// bias is added to the logits generated by the model prior to sampling. The exact
    /// effect will vary per model, but values between -1 and 1 should decrease or
    /// increase likelihood of selection; values like -100 or 100 should result in a ban
    /// or exclusive selection of the relevant token.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logit_bias: Option<HashMap<String, f32>>,

    /// Whether to return log probabilities of the output tokens or not. If true,
    /// returns the log probabilities of each output token returned in the `content` of
    /// `message`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logprobs: Option<bool>,

    /// The maximum number of [tokens](/tokenizer) that can be generated in the chat
    /// completion.
    ///
    /// The total length of input tokens and generated tokens is limited by the model's
    /// context length.
    /// [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
    /// for counting tokens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<u32>,

    /// How many chat completion choices to generate for each input message. Note that
    /// you will be charged based on the number of generated tokens across all of the
    /// choices. Keep `n` as `1` to minimize costs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub n: Option<u32>,

    /// Whether to enable
    /// [parallel function calling](https://platform.openai.com/docs/guides/function-calling/parallel-function-calling)
    /// during tool use.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parallel_tool_calls: Option<bool>,

    /// Number between -2.0 and 2.0. Positive values penalize new tokens based on
    /// whether they appear in the text so far, increasing the model's likelihood to
    /// talk about new topics.
    ///
    /// [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation/parameter-details)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub presence_penalty: Option<f32>,

    /// An object specifying the format that the model must output. Compatible with
    /// [GPT-4 Turbo](https://platform.openai.com/docs/models/gpt-4-and-gpt-4-turbo) and
    /// all GPT-3.5 Turbo models newer than `gpt-3.5-turbo-1106`.
    ///
    /// Setting to `{ "type": "json_object" }` enables JSON mode, which guarantees the
    /// message the model generates is valid JSON.
    ///
    /// **Important:** when using JSON mode, you **must** also instruct the model to
    /// produce JSON yourself via a system or user message. Without this, the model may
    /// generate an unending stream of whitespace until the generation reaches the token
    /// limit, resulting in a long-running and seemingly "stuck" request. Also note that
    /// the message content may be partially cut off if `finish_reason="length"`, which
    /// indicates the generation exceeded `max_tokens` or the conversation exceeded the
    /// max context length.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub response_format: Option<chat_completion_create_params::ResponseFormat>,
    // !TODO
    // pub response_format: Option<ChatCompletionCreateParams.ResponseFormat>,
    /// This feature is in Beta. If specified, our system will make a best effort to
    /// sample deterministically, such that repeated requests with the same `seed` and
    /// parameters should return the same result. Determinism is not guaranteed, and you
    /// should refer to the `system_fingerprint` response parameter to monitor changes
    /// in the backend.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<u32>,

    /// Specifies the latency tier to use for processing the request. This parameter is
    /// relevant for customers subscribed to the scale tier service:
    ///
    /// - If set to 'auto', the system will utilize scale tier credits until they are
    ///   exhausted.
    /// - If set to 'default', the request will be processed using the default service
    ///   tier with a lower uptime SLA and no latency guarentee.
    ///
    /// When this parameter is set, the response body will include the `service_tier`
    /// utilized.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<ServiceTier>,

    /// Up to 4 sequences where the API will stop generating further tokens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop: Option<Value>,
    // pub stop: Option<String | Vec<String>>,
    /// If set, partial message deltas will be sent, like in ChatGPT. Tokens will be
    /// sent as data-only
    /// [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format)
    /// as they become available, with the stream terminated by a `data: [DONE]`
    /// message.
    /// [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stream: Option<bool>,

    /// Options for streaming response. Only set this when you set `stream: true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stream_options: Option<ChatCompletionStreamOptions>,

    /// What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
    /// make the output more random, while lower values like 0.2 will make it more
    /// focused and deterministic.
    ///
    /// We generally recommend altering this or `top_p` but not both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f32>,

    /// Controls which (if any) tool is called by the model. `none` means the model will
    /// not call any tool and instead generates a message. `auto` means the model can
    /// pick between generating a message or calling one or more tools. `required` means
    /// the model must call one or more tools. Specifying a particular tool via
    /// `{"type": "function", "function": {"name": "my_function"}}` forces the model to
    /// call that tool.
    ///
    /// `none` is the default when no tools are present. `auto` is the default if tools
    /// are present.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_choice: Option<ChatCompletionToolChoiceOption>,

    /// A list of tools the model may call. Currently, only functions are supported as a
    /// tool. Use this to provide a list of functions the model may generate JSON inputs
    /// for. A max of 128 functions are supported.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<ChatCompletionTool>>,

    /// An integer between 0 and 20 specifying the number of most likely tokens to
    /// return at each token position, each with an associated log probability.
    /// `logprobs` must be set to `true` if this parameter is used.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_logprobs: Option<u8>,

    /// An alternative to sampling with temperature, called nucleus sampling, where the
    /// model considers the results of the tokens with top_p probability mass. So 0.1
    /// means only the tokens comprising the top 10% probability mass are considered.
    ///
    /// We generally recommend altering this or `temperature` but not both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f32>,

    /// A unique identifier representing your end-user, which can help OpenAI to monitor
    /// and detect abuse.
    /// [Learn more](https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

pub mod chat_completion_create_params {
    use super::*;

    #[derive(Default, Debug, Clone, Deserialize, Serialize)]
    #[deprecated]
    pub struct Function {
        /// The name of the function to be called. Must be a-z, A-Z, 0-9, or contain
        /// underscores and dashes, with a maximum length of 64.
        pub name: String,

        /// A description of what the function does, used by the model to choose when and
        /// how to call the function.
        #[serde(skip_serializing_if = "Option::is_none")]
        pub description: Option<String>,

        /// The parameters the functions accepts, described as a JSON Schema object. See the
        /// [guide](https://platform.openai.com/docs/guides/function-calling) for examples,
        /// and the
        /// [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for
        /// documentation about the format.
        ///
        /// Omitting `parameters` defines a function with an empty parameter list.
        #[serde(skip_serializing_if = "Option::is_none")]
        pub parameters: Option<shared::FunctionParameters>,
    }

    /// An object specifying the format that the model must output. Compatible with
    /// [GPT-4 Turbo](https://platform.openai.com/docs/models/gpt-4-and-gpt-4-turbo) and
    /// all GPT-3.5 Turbo models newer than `gpt-3.5-turbo-1106`.
    ///
    /// Setting to `{ "type": "json_object" }` enables JSON mode, which guarantees the
    /// message the model generates is valid JSON.
    ///
    /// **Important:** when using JSON mode, you **must** also instruct the model to
    /// produce JSON yourself via a system or user message. Without this, the model may
    /// generate an unending stream of whitespace until the generation reaches the token
    /// limit, resulting in a long-running and seemingly "stuck" request. Also note that
    /// the message content may be partially cut off if `finish_reason="length"`, which
    /// indicates the generation exceeded `max_tokens` or the conversation exceeded the
    /// max context length.
    #[derive(Default, Debug, Clone, Serialize, Deserialize)]
    pub struct ResponseFormat {
        /// Must be one of `text` or `json_object`.
        #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
        response_format_type: Option<String>, // 'text' | 'json_object';
    }

    //   export type ChatCompletionCreateParamsNonStreaming =
    //     ChatCompletionsAPI.ChatCompletionCreateParamsNonStreaming;
    //   export type ChatCompletionCreateParamsStreaming = ChatCompletionsAPI.ChatCompletionCreateParamsStreaming;
}

// /// @deprecated Use ChatCompletionCreateParams instead
// export type CompletionCreateParams = ChatCompletionCreateParams;

#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct ChatCompletionCreateParamsNonStreaming {
    // extends ChatCompletionCreateParamsBase
    /// If set, partial message deltas will be sent, like in ChatGPT. Tokens will be
    /// sent as data-only
    /// [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format)
    /// as they become available, with the stream terminated by a `data: [DONE]`
    /// message.
    /// [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stream: Option<bool>, // false | null
}

// /// @deprecated Use ChatCompletionCreateParamsNonStreaming instead
// export type CompletionCreateParamsNonStreaming = ChatCompletionCreateParamsNonStreaming;
//
pub struct ChatCompletionCreateParamsStreaming {
    // extends ChatCompletionCreateParamsBase
    /// If set, partial message deltas will be sent, like in ChatGPT. Tokens will be
    /// sent as data-only
    /// [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format)
    /// as they become available, with the stream terminated by a `data: [DONE]`
    /// message.
    /// [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions).
    pub stream: bool, // true
}

// /// @deprecated Use ChatCompletionCreateParamsStreaming instead
// export type CompletionCreateParamsStreaming = ChatCompletionCreateParamsStreaming;