Struct ExtractFailure 

pub struct ExtractFailure { /* private fields */ }

Available on crate feature extract only.

A failed extraction: why it failed, the last provider response, and the record of the passes it made.

Carried by Error::Extract:

use allama::extract::{ExtractError, ExtractionMode, Extractor};
use allama::mock::{ChatResponseBuilder, MockProvider};
use allama::schemars::{self, JsonSchema};
use allama::{ChatRequest, Error};

#[derive(Debug, serde::Deserialize, JsonSchema)]
struct Person {
    name: String,
}

let provider = MockProvider::build(|b| {
    b.response(ChatResponseBuilder::new().text("not json").usage(10, 3).build())
        .response(ChatResponseBuilder::new().text("still not json").usage(14, 4).build())
});
let request = ChatRequest::new("m")
    .user("Ada wrote the first program.")
    .with_option(ExtractionMode::Native);
let Err(Error::Extract { failure, .. }) = Extractor::new()
    .retries(1)
    .extract::<_, Person>(&provider, &request)
    .await
else {
    panic!("expected an extraction failure");
};
assert!(matches!(failure.error(), ExtractError::Parse { .. }));
assert_eq!(failure.response().and_then(|r| r.text()).as_deref(), Some("still not json"));
assert_eq!(failure.metadata().passes, 2);
assert_eq!(failure.metadata().usage.as_ref().and_then(|u| u.input_tokens), Some(24));

Error’s serde form includes the response; its redacted logging view (Error::as_log) does not. Its Debug withholds the response, and the model’s text in the error (see ExtractError).

Implementations

impl ExtractFailure

pub fn new(error: ExtractError, metadata: ExtractionMetadata) -> Self

A failure without a response (extraction stopped before or without one).

pub fn with_response(self, response: ChatResponse) -> Self

Attach the response whose output could not be used.

pub fn error(&self) -> &ExtractError

Why extraction failed.

pub fn response(&self) -> Option<&ChatResponse>

The last provider response: the one whose output could not be used. None when extraction failed before calling the provider.

pub fn metadata(&self) -> &ExtractionMetadata

How the extraction ran up to the failure: mode, provider calls made, and their summed usage.

pub fn into_response(self) -> Option<ChatResponse>

Take the last provider response.

Trait Implementations

impl Clone for ExtractFailure

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 ExtractFailure

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExtractFailure

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExtractFailure

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

Formats the value using the given formatter.

impl Error for ExtractFailure

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ExtractFailure> for Error

fn from(failure: ExtractFailure) -> Self

Converts to this type from the input type.

impl Serialize for ExtractFailure

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

where __S: Serializer,

Serialize this value into the given Serde serializer.