Struct LlmOutcome 

pub struct LlmOutcome {
    pub ok: bool,
    pub text: Option<String>,
    pub failure: Option<LlmFailure>,
    pub input_tokens: Option<u64>,
    pub output_tokens: Option<u64>,
}

One element’s result, positionally matched to the prompt that produced it.

A struct rather than an enum because success and failure are not disjoint here: a truncated or content-filtered completion is ok: false and still carries usable text, and a caller that wants the partial answer should not have to reach through an error arm to get it.

ok: true means the provider reported a natural stop — not merely that no error was raised. A completion that returned cleanly but stopped on length is ok: false with FailureReason::Truncated. That choice trades a class of silent wrong-answer bugs for one honest data-loss risk, which is why the failure arm keeps its text rather than discarding it.

The arms differ in more than a flag: text is always present on success and nullable on failure, and the LlmFailure payload exists only on failure.

Fields

ok: bool

The provider reported a natural stop for this element.

text: Option<String>

The completion text.

Always Some on the success arm. On the failure arm it is string | null: Some — including Some("") — when the model produced text, and None when it produced none at all. The two must not collapse, since telling “empty because filtered” from “empty because the model said nothing” is the distinction the ok rule exists to preserve.

failure: Option<LlmFailure>

The failure payload. Some exactly when !ok.

input_tokens: Option<u64>

Tokens the provider reported for the prompt. None means indeterminate, not free — the provider reported nothing, or reported something non-finite. Never Some(0) as a stand-in for “unknown”: a throttled call may still have been billed, so a reconciler holds a conservative reserve for None rather than releasing it.

Nullable on both arms: a provider can resolve successfully with no usage reported, so this cannot be confined to the failure arm.

output_tokens: Option<u64>

Tokens the provider reported for the completion. Same None-means-indeterminate rule as Self::input_tokens.

Implementations

impl LlmOutcome

pub fn success(text: impl Into<String>) -> Self

A natural stop with the given text. Usage is left indeterminate; a provider that reports counts sets them explicitly.

pub fn failed(failure: LlmFailure, text: Option<impl Into<String>>) -> Self

A non-clean element. text is whatever the model did produce: Some when it produced any, None when it produced none — retained rather than discarded, so a partial answer survives.

pub fn with_usage( self, input_tokens: Option<u64>, output_tokens: Option<u64>, ) -> Self

Attach reported usage. A non-finite or unreported count stays None.

Trait Implementations

impl Clone for LlmOutcome

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 LlmOutcome

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

Formats the value using the given formatter.

impl Eq for LlmOutcome

impl PartialEq for LlmOutcome

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LlmOutcome