Struct ChatCompletionStreamRequest 

pub struct ChatCompletionStreamRequest {

    pub model: String,
    pub messages: Vec<ChatCompletionMessage>,
    pub temperature: Option<f64>,
    pub top_p: Option<f64>,
    pub n: Option<i64>,
    pub response_format: Option<Value>,
    pub stop: Option<Vec<String>>,
    pub max_tokens: Option<i64>,
    pub presence_penalty: Option<f64>,
    pub frequency_penalty: Option<f64>,
    pub logit_bias: Option<HashMap<String, i32>>,
    pub user: Option<String>,
    pub seed: Option<i64>,
    pub tools: Option<Vec<Tool>>,
    pub parallel_tool_calls: Option<bool>,
    pub tool_choice: Option<ToolChoiceType>,
    pub reasoning: Option<Reasoning>,
    pub transforms: Option<Vec<String>>,
}

Fields

model: String

messages: Vec<ChatCompletionMessage>

temperature: Option<f64>

top_p: Option<f64>

n: Option<i64>

response_format: Option<Value>

stop: Option<Vec<String>>

max_tokens: Option<i64>

presence_penalty: Option<f64>

frequency_penalty: Option<f64>

logit_bias: Option<HashMap<String, i32>>

user: Option<String>

seed: Option<i64>

tools: Option<Vec<Tool>>

parallel_tool_calls: Option<bool>

tool_choice: Option<ToolChoiceType>

reasoning: Option<Reasoning>

transforms: Option<Vec<String>>

Optional list of transforms to apply to the chat completion request.

Transforms allow modifying the request before it’s sent to the API, enabling features like prompt rewriting, content filtering, or other preprocessing steps. When None, no transforms are applied.

Implementations

impl ChatCompletionStreamRequest

pub fn new(model: String, messages: Vec<ChatCompletionMessage>) -> Self

Examples found in repository

examples/chat_completion_stream.rs (lines 15-24)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let req = ChatCompletionStreamRequest::new(
        GPT4_O_MINI.to_string(),
        vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: chat_completion::Content::Text(String::from("What is bitcoin?")),
            name: None,
            tool_calls: None,
            tool_call_id: None,
        }],
    );

    let mut result = client.chat_completion_stream(req).await?;
    while let Some(response) = result.next().await {
        match response.clone() {
            ChatCompletionStreamResponse::ToolCall(toolcalls) => {
                println!("Tool Call: {:?}", toolcalls);
            }
            ChatCompletionStreamResponse::Content(content) => {
                println!("Content: {:?}", content);
            }
            ChatCompletionStreamResponse::Done => {
                println!("Done");
            }
        }
    }

    Ok(())
}

impl ChatCompletionStreamRequest

pub fn temperature(self, temperature: f64) -> Self

pub fn top_p(self, top_p: f64) -> Self

pub fn n(self, n: i64) -> Self

pub fn response_format(self, response_format: Value) -> Self

pub fn stop(self, stop: Vec<String>) -> Self

pub fn max_tokens(self, max_tokens: i64) -> Self

pub fn presence_penalty(self, presence_penalty: f64) -> Self

pub fn frequency_penalty(self, frequency_penalty: f64) -> Self

pub fn logit_bias(self, logit_bias: HashMap<String, i32>) -> Self

pub fn user(self, user: String) -> Self

pub fn seed(self, seed: i64) -> Self

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

pub fn parallel_tool_calls(self, parallel_tool_calls: bool) -> Self

pub fn tool_choice(self, tool_choice: ToolChoiceType) -> Self

pub fn reasoning(self, reasoning: Reasoning) -> Self

pub fn transforms(self, transforms: Vec<String>) -> Self

Trait Implementations

impl Clone for ChatCompletionStreamRequest

fn clone(&self) -> ChatCompletionStreamRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChatCompletionStreamRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChatCompletionStreamRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ChatCompletionStreamRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.