Struct ResponsesCreateRequest 

pub struct ResponsesCreateRequest {

    pub aspect_ratio: Option<String>,
    pub attachment: Option<AttachmentInput>,
    pub attachments: Option<Attachments>,
    pub duration: Option<f64>,
    pub image_url: Option<String>,
    pub include: Vec<String>,
    pub input: Value,
    pub instructions: Option<String>,
    pub language: Option<String>,
    pub max_output_tokens: Option<i64>,
    pub metadata: Map<String, Value>,
    pub modalities: Vec<ResponsesCreateRequestModalitiesItem>,
    pub model: String,
    pub n: Option<i64>,
    pub parallel_tool_calls: Option<bool>,
    pub previous_response_id: Option<String>,
    pub prompt_cache_key: Option<String>,
    pub prompt_cache_retention: Option<String>,
    pub quality: Option<String>,
    pub reasoning: Option<ReasoningOptions>,
    pub reasoning_effort: Option<String>,
    pub resolution: Option<String>,
    pub response_format: Option<ResponseFormat>,
    pub service_tier: Option<String>,
    pub size: Option<String>,
    pub speed: Option<f64>,
    pub store: Option<bool>,
    pub stream: Option<bool>,
    pub stream_options: Option<StreamOptions>,
    pub temperature: Option<f64>,
    pub text: Map<String, Value>,
    pub tool_choice: Option<Value>,
    pub tools: Vec<Map<String, Value>>,
    pub voice: Option<String>,
}

ResponsesCreateRequest

JSON schema

{
 "type": "object",
 "required": [
   "input",
   "model"
 ],
 "properties": {
   "aspect_ratio": {
     "type": "string"
   },
   "attachment": {
     "$ref": "#/components/schemas/AttachmentInput"
   },
   "attachments": {
     "$ref": "#/components/schemas/Attachments"
   },
   "duration": {
     "type": "number"
   },
   "image_url": {
     "type": "string"
   },
   "include": {
     "type": "array",
     "items": {
       "type": "string"
     }
   },
   "input": {},
   "instructions": {
     "type": "string"
   },
   "language": {
     "type": "string"
   },
   "max_output_tokens": {
     "type": "integer"
   },
   "metadata": {
     "type": "object",
     "additionalProperties": true
   },
   "modalities": {
     "type": "array",
     "items": {
       "type": "string",
       "enum": [
         "text",
         "image",
         "audio",
         "video",
         "embedding"
       ]
     }
   },
   "model": {
     "type": "string"
   },
   "n": {
     "type": "integer"
   },
   "parallel_tool_calls": {
     "type": "boolean"
   },
   "previous_response_id": {
     "type": "string"
   },
   "prompt_cache_key": {
     "type": "string"
   },
   "prompt_cache_retention": {
     "type": "string"
   },
   "quality": {
     "type": "string"
   },
   "reasoning": {
     "$ref": "#/components/schemas/ReasoningOptions"
   },
   "reasoning_effort": {
     "type": "string"
   },
   "resolution": {
     "type": "string"
   },
   "response_format": {
     "$ref": "#/components/schemas/ResponseFormat"
   },
   "service_tier": {
     "type": "string"
   },
   "size": {
     "type": "string"
   },
   "speed": {
     "type": "number"
   },
   "store": {
     "type": "boolean"
   },
   "stream": {
     "type": "boolean"
   },
   "stream_options": {
     "$ref": "#/components/schemas/StreamOptions"
   },
   "temperature": {
     "type": "number"
   },
   "text": {
     "type": "object",
     "additionalProperties": true
   },
   "tool_choice": {},
   "tools": {
     "type": "array",
     "items": {
       "type": "object",
       "additionalProperties": true
     }
   },
   "voice": {
     "type": "string"
   }
 },
 "additionalProperties": true
}

Fields

aspect_ratio: Option<String>

attachment: Option<AttachmentInput>

attachments: Option<Attachments>

duration: Option<f64>

image_url: Option<String>

include: Vec<String>

input: Value

instructions: Option<String>

language: Option<String>

max_output_tokens: Option<i64>

metadata: Map<String, Value>

modalities: Vec<ResponsesCreateRequestModalitiesItem>

model: String

n: Option<i64>

parallel_tool_calls: Option<bool>

previous_response_id: Option<String>

prompt_cache_key: Option<String>

prompt_cache_retention: Option<String>

quality: Option<String>

reasoning: Option<ReasoningOptions>

reasoning_effort: Option<String>

resolution: Option<String>

response_format: Option<ResponseFormat>

service_tier: Option<String>

size: Option<String>

speed: Option<f64>

store: Option<bool>

stream: Option<bool>

stream_options: Option<StreamOptions>

temperature: Option<f64>

text: Map<String, Value>

tool_choice: Option<Value>

tools: Vec<Map<String, Value>>

voice: Option<String>

Implementations

impl ResponsesCreateRequest

pub fn builder() -> ResponsesCreateRequest

Trait Implementations

impl Clone for ResponsesCreateRequest

fn clone(&self) -> ResponsesCreateRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResponsesCreateRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResponsesCreateRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ResponsesCreateRequest> for ResponsesCreateRequest

fn from(value: ResponsesCreateRequest) -> Self

Converts to this type from the input type.

impl Serialize for ResponsesCreateRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<ResponsesCreateRequest> for ResponsesCreateRequest

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: ResponsesCreateRequest) -> Result<Self, ConversionError>

Performs the conversion.