Struct ResponsesRequest 

pub struct ResponsesRequest {

    pub client: DeepSeekClient,
    pub model: String,
    pub input: Option<Input>,
    pub instructions: Option<String>,
    pub reasoning: Option<Reasoning>,
    pub max_output_tokens: Option<u32>,
    pub stream: Option<bool>,
    pub temperature: Option<f64>,
    pub top_p: Option<f64>,
    pub text: Option<Text>,
    pub tools: Vec<Tool>,
    pub tool_choice: Option<ToolChoice>,
    pub top_logprobs: Option<u32>,
    pub user: Option<String>,
}

Responses request body for the OpenAI Responses API format.

Fields

client: DeepSeekClient

model: String

ID of the model to use. The Responses API currently only supports deepseek-v4-flash.

input: Option<Input>

The input to the model. Either a plain string (treated as a single user message), or a list of input items.

At least one of input and instructions is required.

instructions: Option<String>

A system-level instruction, inserted as the first system message of the model’s context.

reasoning: Option<Reasoning>

Configuration of the thinking mode.

max_output_tokens: Option<u32>

An upper bound for the number of tokens that can be generated in the response, including both the visible output tokens and the reasoning tokens.

stream: Option<bool>

If set to true, the response is streamed as semantic server-sent events. The final event is response.completed / response.incomplete / response.failed (there is no data: [DONE] message).

temperature: Option<f64>

Possible values: <= 2

Default value: 1

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. Has no effect in thinking mode.

top_p: Option<f64>

Possible values: <= 1

Default value: 1

An alternative to sampling with temperature, called nucleus sampling. Has no effect in thinking mode.

text: Option<Text>

Configuration of the text output.

tools: Vec<Tool>

A list of tools the model may call. Function names must be non-empty, at most 128 characters, match ^[a-zA-Z0-9_-]+$, and be unique across all tools. Besides function, the built-in web_search tool is supported and executed on the server side.

tool_choice: Option<ToolChoice>

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 (default) 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", "name": "my_function"} forces the model to call that tool.

top_logprobs: Option<u32>

Possible values: <= 20

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.

user: Option<String>

A custom end-user identifier, with allowed character set [a-zA-Z0-9\-_] and a maximum length of 512. Do not include user privacy information.

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 DeepSeekRequest for ResponsesRequest

type Response = Response

Full response type for non-streaming calls.

type StreamItem = Result<ResponsesStreamEvent, DeepSeekError>

Item type emitted by streaming calls.

type BlockingStream = ResponsesStreamBlocking

Blocking stream iterator type.

async fn send(self) -> Result<Response, DeepSeekError>

Send a non-streaming request.

async fn stream(self) -> Result<Receiver<ResponsesStreamItem>, DeepSeekError>

Send a streaming request (SSE), returning a receiver of stream items.

fn stream_blocking(self) -> Result<ResponsesStreamBlocking, DeepSeekError>

Send a streaming request but consume results via a blocking iterator.

impl PartialEq for ResponsesRequest

fn eq(&self, other: &ResponsesRequest) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

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 StructuralPartialEq for ResponsesRequest