Struct ChatCompletionRequest 

pub struct ChatCompletionRequest {

    pub model: String,
    pub messages: Vec<ChatMessage>,
    pub temperature: Option<f32>,
    pub max_tokens: Option<u32>,
    pub top_p: Option<f32>,
    pub frequency_penalty: Option<f32>,
    pub presence_penalty: Option<f32>,
    pub stop: Option<Vec<String>>,
    pub user: Option<String>,
    pub provider: Option<String>,
    pub stream: Option<bool>,
    pub logit_bias: Option<Value>,
    pub logprobs: Option<bool>,
    pub top_logprobs: Option<u32>,
    pub n: Option<u32>,
    pub response_format: Option<ResponseFormat>,
    pub tools: Option<Vec<Tool>>,
    pub tool_choice: Option<ToolChoice>,
}

Represents a request to create a chat completion.

Fields

model: String

The identifier of the model to use for the completion (e.g., “gpt-4o”, “claude-sonnet-4”).

messages: Vec<ChatMessage>

A list of messages that form the conversation history.

temperature: Option<f32>

The sampling temperature to use, between 0.0 and 2.0. Higher values will make the output more random, while lower values will make it more focused and deterministic.

max_tokens: Option<u32>

The maximum number of tokens to generate in the completion.

top_p: Option<f32>

The nucleus sampling parameter. 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.

frequency_penalty: Option<f32>

A penalty applied to new tokens based on their frequency in the text so far. It decreases the model’s likelihood to repeat the same line verbatim.

presence_penalty: Option<f32>

A penalty applied to new tokens based on whether they appear in the text so far. It increases the model’s likelihood to talk about new topics.

stop: Option<Vec<String>>

A list of sequences that will cause the model to stop generating further tokens.

user: Option<String>

A unique identifier representing your end-user, which can help in monitoring and tracking conversations.

provider: Option<String>

A hint to the router about which provider to use for the model.

stream: Option<bool>

If set to true, the response will be streamed as a series of events.

logit_bias: Option<Value>

Modify the likelihood of specified tokens appearing in the completion.

logprobs: Option<bool>

Whether to return log probabilities of the output tokens.

top_logprobs: Option<u32>

An integer between 0 and 20 specifying the number of most likely tokens to return at each token position.

n: Option<u32>

How many chat completion choices to generate for each input message.

response_format: Option<ResponseFormat>

An object specifying the format that the model must output.

tools: Option<Vec<Tool>>

A list of tools the model may call.

tool_choice: Option<ToolChoice>

Controls which (if any) tool is called by the model.

Implementations

impl ChatCompletionRequest

pub fn new(model: impl Into<String>, messages: Vec<ChatMessage>) -> Self

Creates a new ChatCompletionRequest with the given model and messages.

Arguments

• model - The identifier of the model to use.
• messages - The list of messages for the conversation.

pub fn with_temperature(self, temperature: f32) -> Self

Sets the temperature for the chat completion.

The temperature is clamped between 0.0 and 2.0.

Arguments

• temperature - The sampling temperature.

pub fn with_max_tokens(self, max_tokens: u32) -> Self

Sets the maximum number of tokens to generate.

Arguments

• max_tokens - The maximum number of tokens.

pub fn with_user(self, user: impl Into<String>) -> Self

Sets the user identifier for the chat completion.

Arguments

• user - A unique identifier for the end-user.

pub fn with_provider(self, provider: impl Into<String>) -> Self

Sets a provider hint for the request.

Arguments

• provider - The name of the provider to use.

pub fn with_stream(self, stream: bool) -> Self

Enables or disables streaming for the response.

Arguments

• stream - true to enable streaming, false to disable.

pub fn with_logit_bias(self, logit_bias: Value) -> Self

Sets the logit bias for the chat completion.

Arguments

• logit_bias - A map of token IDs to bias values.

pub fn with_logprobs(self, logprobs: bool) -> Self

Enables or disables log probabilities for the response.

Arguments

• logprobs - true to include log probabilities.

pub fn with_top_logprobs(self, top_logprobs: u32) -> Self

Sets the number of most likely tokens to return at each position.

Arguments

• top_logprobs - The number of top log probabilities to return.

pub fn with_n(self, n: u32) -> Self

Sets the number of chat completion choices to generate.

Arguments

• n - The number of completions to generate.

pub fn with_response_format(self, response_format: ResponseFormat) -> Self

Sets the response format for the chat completion.

Arguments

• response_format - The format the model must output.

pub fn with_tools(self, tools: Vec<Tool>) -> Self

Sets the tools available to the model.

Arguments

• tools - A list of tools the model can use.

pub fn with_tool_choice(self, tool_choice: ToolChoice) -> Self

Sets the tool choice for the chat completion.

Arguments

• tool_choice - Controls which tool the model uses.

pub fn validate_openai_compatibility(&self) -> Result<(), String>

Validates that the request parameters are compatible with OpenAI standards.

This method checks parameter ranges and values to ensure they match OpenAI’s API specifications.

Returns

A Result indicating whether the request is valid for OpenAI compatibility.

Trait Implementations

impl Clone for ChatCompletionRequest

fn clone(&self) -> ChatCompletionRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChatCompletionRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChatCompletionRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ChatCompletionRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.