Struct ResponsesRequest 

pub struct ResponsesRequest {

    pub background: Option<bool>,
    pub include: Option<Vec<IncludeField>>,
    pub input: ResponseInput,
    pub instructions: Option<String>,
    pub max_output_tokens: Option<u32>,
    pub max_tool_calls: Option<u32>,
    pub metadata: Option<HashMap<String, Value>>,
    pub model: String,
    pub conversation: Option<String>,
    pub parallel_tool_calls: Option<bool>,
    pub previous_response_id: Option<String>,
    pub reasoning: Option<ResponseReasoningParam>,
    pub service_tier: Option<ServiceTier>,
    pub store: Option<bool>,
    pub stream: Option<bool>,
    pub temperature: Option<f32>,
    pub tool_choice: Option<ToolChoice>,
    pub tools: Option<Vec<ResponseTool>>,
    pub top_logprobs: Option<u32>,
    pub top_p: Option<f32>,
    pub truncation: Option<Truncation>,
    pub text: Option<TextConfig>,
    pub user: Option<String>,
    pub request_id: Option<String>,
    pub priority: i32,
    pub frequency_penalty: Option<f32>,
    pub presence_penalty: Option<f32>,
    pub stop: Option<StringOrArray>,
    pub top_k: i32,
    pub min_p: f32,
    pub repetition_penalty: f32,
}

Fields

background: Option<bool>

Run the request in the background

include: Option<Vec<IncludeField>>

Fields to include in the response

input: ResponseInput

Input content - can be string or structured items

instructions: Option<String>

System instructions for the model

max_output_tokens: Option<u32>

Maximum number of output tokens

max_tool_calls: Option<u32>

Maximum number of tool calls

metadata: Option<HashMap<String, Value>>

Additional metadata

model: String

Model to use

conversation: Option<String>

Optional conversation id to persist input/output as items

parallel_tool_calls: Option<bool>

Whether to enable parallel tool calls

previous_response_id: Option<String>

ID of previous response to continue from

reasoning: Option<ResponseReasoningParam>

Reasoning configuration

service_tier: Option<ServiceTier>

Service tier

store: Option<bool>

Whether to store the response

stream: Option<bool>

Whether to stream the response

temperature: Option<f32>

Temperature for sampling

tool_choice: Option<ToolChoice>

Tool choice behavior

tools: Option<Vec<ResponseTool>>

Available tools

top_logprobs: Option<u32>

Number of top logprobs to return

top_p: Option<f32>

Top-p sampling parameter

truncation: Option<Truncation>

Truncation behavior

text: Option<TextConfig>

Text format for structured outputs (text, json_object, json_schema)

user: Option<String>

User identifier

request_id: Option<String>

Request ID

priority: i32

Request priority

frequency_penalty: Option<f32>

Frequency penalty

presence_penalty: Option<f32>

Presence penalty

stop: Option<StringOrArray>

Stop sequences

top_k: i32

Top-k sampling parameter (SGLang extension)

min_p: f32

Min-p sampling parameter (SGLang extension)

repetition_penalty: f32

Repetition penalty (SGLang extension)

Trait Implementations

impl Clone for ResponsesRequest

fn clone(&self) -> ResponsesRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResponsesRequest

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

Formats the value using the given formatter.

impl Default for ResponsesRequest

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ResponsesRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl GenerationRequest for ResponsesRequest

fn is_stream(&self) -> bool

Check if the request is for streaming

fn get_model(&self) -> Option<&str>

Get the model name if specified

fn extract_text_for_routing(&self) -> String

Extract text content for routing decisions

impl Normalizable for ResponsesRequest

fn normalize(&mut self)

Normalize the request by applying defaults:

1. Apply tool_choice defaults based on tools presence
2. Apply parallel_tool_calls defaults
3. Apply store field defaults

impl Serialize for ResponsesRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Validate for ResponsesRequest

fn validate(&self) -> Result<(), ValidationErrors>

impl<'v_a> ValidateArgs<'v_a> for ResponsesRequest

type Args = ()

fn validate_with_args(&self, args: Self::Args) -> Result<(), ValidationErrors>