Struct CompletionResponse 

#[non_exhaustive]
pub struct CompletionResponse {
    pub choice: Vec<AssistantContent>,
    pub usage: Usage,
    pub origin: Origin,
    pub error: Option<String>,
    pub aborted: Option<String>,
    pub provider_request_id: Option<String>,
    pub raw: Value,
    /* private fields */
}

Assistant content and normalized completion metadata. The choice may be empty, including for truncated or filtered turns. Provider-specific data is available through Self::raw without retaining a concrete model type.

A response goes straight back into the conversation as the assistant turn: history.extend(response.message()).

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

choice: Vec<AssistantContent>

Assistant content returned by the provider, one block per provider output item, in provider order. Possibly empty.

usage: Usage

Tokens used during prompting and responding

origin: Origin

The wire, provider and requested model that produced the response, with the model and response id the provider reported.

error: Option<String>

The provider’s report that the turn failed, such as a refusal’s explanation. The turn’s message then ends in StopReason::Error and is never replayed.

aborted: Option<String>

Why the reply stopped before the provider ended it, when the caller stopped reading: the turn’s message then ends in StopReason::Aborted and is never replayed.

provider_request_id: Option<String>

Request identifier from HTTP headers or SDK metadata, not the body’s response ID. None when the provider reports none.

raw: Value

Provider response document for typed inspection through deserialization. Parsed wire types may omit unmodeled fields. This data does not override normalized fields; callers constructing responses must supply it.

Implementations

impl CompletionResponse

pub fn new( choice: Vec<AssistantContent>, usage: Usage, origin: Origin, raw: Value, ) -> Self

Create a response from its required parts; optional metadata starts unset. raw is the provider’s own document for this response, serialized; see Self::raw.

pub fn provider(&self) -> &str

The provider descriptor name ("openai").

pub fn extras<P: ProviderExtension>(&self) -> Option<Result<P::Extras, Error>>

P’s typed view of Self::raw. None unless P is the provider that produced the reply.

Errors

The inner result fails when raw does not hold P’s extras.

pub fn extras_lossy<P: ProviderExtension>(&self) -> P::Extras

where P::Extras: Default,

P’s typed view of Self::raw, or the empty view (every field None) when it cannot be read: when another provider produced the reply, or when raw does not hold P’s extras. A decode failure is logged at debug; use Self::extras to tell the cases apart.

pub fn model(&self) -> Option<&str>

The model the provider reported, when it reported one.

pub fn response_id(&self) -> Option<&str>

The provider’s response id, when it sent one.

pub fn finish_reason(&self) -> Option<FinishReason>

Why the model stopped generating, when the provider reported it.

pub fn accepts_unknown_finish_reasons(&self) -> bool

Whether a finish reason outside the normalized vocabulary ends the turn as a normal stop, as the request asked (CompletionRequest::accept_unknown_finish_reasons).

pub fn accept_unknown_finish_reasons(self, accept: bool) -> Self

Accept, or refuse, FinishReason::Other as a normal stop in Self::stop. Filtered content and a reported failure still fail.

pub fn stop(&self) -> StopReason

How the turn ended, for history. It fails closed: only a natural stop, the token limit and a stop to call tools are successes. A reported failure, filtered content and any finish reason outside that set are StopReason::Error, unless the response accepts unknown reasons (Self::accepts_unknown_finish_reasons), which then stop like FinishReason::Stop. A reply the caller stopped reading is StopReason::Aborted.

pub fn identity(&self) -> ResponseIdentity

This response’s identity metadata as one ResponseIdentity carrier.

pub fn with_finish_reason(self, finish_reason: FinishReason) -> Self

Attach the normalized finish reason, reconciled against the choice via FinishReason::reconcile_with_output.

pub fn text(&self) -> String

The text parts of Self::choice, concatenated in order.

pub fn reasoning(&self) -> String

The reasoning text of Self::choice, concatenated in order. Redacted reasoning has no text.

pub fn message(&self) -> Option<Message>

The assistant turn to append to the conversation: Self::choice in order with its origin and stop, or None for an empty choice.

pub fn continued(&self, content: Vec<AssistantContent>) -> AssistantMessage

The turn this response began, holding content, for a runtime that cut the reply short and answers its calls itself (an agent rolling a turn back over an invalid call). It keeps the origin, and stops to call tools, since the runtime answers them. A block keeps its provider item only when this response holds the same block with it. A response the provider did not end, or one the consumer has not wholly taken, holds no provider item, so its turn replays canonically.

pub fn head(&self) -> AssistantMessage

The turn’s origin and stop with no content, for a runtime that carries the content separately.

pub fn tool_calls(&self) -> impl Iterator<Item = &ToolCall>

The tool calls in Self::choice, in order.

pub fn with_optional_finish_reason( self, finish_reason: Option<FinishReason>, ) -> Self

Sets or clears the finish reason, reconciling a present reason with the choice.

Trait Implementations

impl Clone for CompletionResponse

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompletionResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompletionResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CompletionResponse

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CompletionResponse

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 CompletionResponse