Struct ModelResponse 

pub struct ModelResponse {
    pub request_id: RequestId,
    pub provider: ProviderKey,
    pub model: ModelKey,
    pub content: Vec<ContentPart>,
    pub finish: FinishReason,
    pub usage: TokenUsage,
    pub raw_id: Option<String>,
    pub latency: Duration,
    pub warnings: Vec<ResponseWarning>,
}

One model answer (spec §20.1).

Fields

request_id: RequestId

The request this answers. Equal to ModelRequest::request_id even after a retry.

provider: ProviderKey

Which provider answered.

model: ModelKey

Which model answered. May differ from the requested key when the provider resolved an alias; the reported model is recorded.

content: Vec<ContentPart>

The answer, in order.

finish: FinishReason

Why generation stopped.

usage: TokenUsage

Reported tokens.

raw_id: Option<String>

The provider’s own response identifier, for support tickets. Never a body and never a header.

latency: Duration

Wall-clock duration of the call, measured by the adapter.

warnings: Vec<ResponseWarning>

Adapter warnings.

Implementations

impl ModelResponse

pub fn new( request_id: RequestId, provider: impl Into<ProviderKey>, model: impl Into<ModelKey>, ) -> Self

A response with no content, for adapters to build on.

pub fn with_part(self, part: ContentPart) -> Self

Appends a content part.

pub fn with_text(self, text: impl Into<String>) -> Self

Appends a text part.

pub fn with_tool_call(self, call: ToolCall) -> Self

Appends a tool call.

pub const fn with_finish(self, finish: FinishReason) -> Self

Sets the finish reason.

pub const fn with_usage(self, usage: TokenUsage) -> Self

Sets the reported usage.

pub fn with_raw_id(self, raw_id: impl Into<String>) -> Self

Sets the provider’s response identifier.

pub const fn with_latency(self, latency: Duration) -> Self

Sets the measured latency.

pub fn with_warning(self, warning: ResponseWarning) -> Self

Adds a warning.

pub fn reference(&self) -> ModelRef

The provider-model pair that answered.

pub fn text(&self) -> String

Every text part, concatenated in order.

use turnframe_provider::prelude::*;

let response = ModelResponse::new(RequestId::nil(), "openai", "gpt-4o")
    .with_text("Ho preparato ")
    .with_text("la modifica.");
assert_eq!(response.text(), "Ho preparato la modifica.");

pub fn tool_calls(&self) -> Vec<&ToolCall>

Every tool call, in the order the model produced them.

pub fn tool_call(&self, id: &CallId) -> Option<&ToolCall>

The call with this id, when present.

pub fn is_empty(&self) -> bool

Returns true when the model produced neither text nor a tool call.

pub fn single_json(&self) -> Result<Value, StructuredOutputError>

Extracts the single JSON document a structured stage expects.

The rule is deterministic and refuses to guess:

1. A FinishReason::Refusal is a Refusal, never a parse attempt.
2. A finish reason that is not complete — truncation, a content filter — is a NoOutput: the bytes that arrived are a prefix, and parsing a prefix is what I18 forbids.
3. Exactly one tool call: its arguments are the document. The surrounding prose is a preamble and is ignored, because a provider using a function schema as a transport routinely emits both.
4. More than one tool call: MultipleCandidates. A stage that expects one document never picks one of several.
5. No tool call: the concatenated text is parsed. A single ```json fence around it is stripped first — a fence is framing a prompt-only transport adds, not content.

Errors

See StructuredOutputError.

Trait Implementations

impl Clone for ModelResponse

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 ModelResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModelResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ModelResponse

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ModelResponse

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 ModelResponse