Struct GenerateResponse 

pub struct GenerateResponse<C = GenerationContinuation> {
    pub model: ModelId,
    pub message: Message<C>,
    pub finish_reason: Option<FinishReason>,
    pub citations: Vec<Citation>,
    pub artifacts: Vec<Artifact>,
    pub hosted_tool_outputs: Vec<HostedToolOutput>,
    pub usage: Usage,
}

Final normalized generation result.

A returned assistant message is the replay owner. Preserve it unchanged through function continuation; projections of text, hosted results, or artifacts cannot reconstruct native state. Serialization fails while continuation is present.

Examples

use providers_kit::{ModelId, generation::{GenerateResponse, Message, FinishReason, Usage}};
let response = GenerateResponse { model: ModelId::new("exact-model")?, message: Message::assistant_text("done")?.with_continuation(7_u32)?, finish_reason: Some(FinishReason::Stop), citations: Vec::new(), artifacts: Vec::new(), hosted_tool_outputs: Vec::new(), usage: Usage::default() };
let mapped = response.try_map_continuation(|value| Ok(value.to_string()))?;
assert_eq!(mapped.message.continuation().map(String::as_str), Some("7"));
assert_eq!(mapped.model.as_str(), "exact-model");

Fields

model: ModelId

Exact model that produced the response.

message: Message<C>

Returned assistant message and opaque continuation state.

finish_reason: Option<FinishReason>

Provider-reported completion reason.

citations: Vec<Citation>

Citations attached to generated output.

artifacts: Vec<Artifact>

Generated artifacts.

hosted_tool_outputs: Vec<HostedToolOutput>

Normalized provider-hosted tool outputs.

usage: Usage

Provider-reported token accounting.

Implementations

impl<C> GenerateResponse<C>

pub fn try_map_continuation<D>( self, map: impl FnMut(C) -> Result<D, KitError>, ) -> Result<GenerateResponse<D>, KitError>

Maps only opaque continuation values.

Errors

Returns the callback error unchanged if converting the response continuation fails; other response fields retain their exact values.

Examples

use providers_kit::{ModelId, generation::{GenerateResponse, Message, FinishReason, Usage}};
let response = GenerateResponse { model: ModelId::new("exact-model")?, message: Message::assistant_text("done")?.with_continuation(7_u32)?, finish_reason: Some(FinishReason::Stop), citations: Vec::new(), artifacts: Vec::new(), hosted_tool_outputs: Vec::new(), usage: Usage::default() };
let mapped = response.try_map_continuation(|value| Ok(value.to_string()))?;
assert_eq!(mapped.message.continuation().map(String::as_str), Some("7"));
assert_eq!(mapped.model.as_str(), "exact-model");

Trait Implementations

impl<C: Clone> Clone for GenerateResponse<C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for GenerateResponse<C>

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for GenerateResponse<C>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C: PartialEq> PartialEq for GenerateResponse<C>

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

Equality operator ==.

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

Inequality operator !=.

impl<C> Serialize for GenerateResponse<C>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C: PartialEq> StructuralPartialEq for GenerateResponse<C>