Enum ScriptedReply 

#[non_exhaustive]
pub enum ScriptedReply {
    Json(Value),
    Text(String),
    ToolCall {
        id: CallId,
        name: String,
        arguments: Value,
    },
    MalformedJson(String),
    Refusal(String),
    Timeout,
    RateLimited {
        retry_after: Option<Duration>,
    },
    Fail(ProviderError),
    Stream(Vec<StreamEvent>),
    Chunks(Vec<String>),
    FromSchema(fn(&Value) -> Value),
}

What one scripted call answers with.

The variants cover the answers a turn has to survive: the plan you meant, the plan you did not mean, a body that is not JSON at all, a refusal, and the three transport failures whose handling differs (timeout, rate limit, anything else).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Json(Value)

An arbitrary JSON document, for the shapes no typed value can express — an act with a field the schema forbids, a plan missing a required field.

Text(String)

Prose.

ToolCall

A single tool call, the shape a native function-schema transport produces.

Fields

id: CallId

Call id echoed back to the runtime.

name: String

Tool name.

arguments: Value

Arguments, still untrusted.

MalformedJson(String)

A body that is not JSON. Sent verbatim, so the test decides how broken it is.

Refusal(String)

The model declined. A semantic outcome (FinishReason::Refusal), not a transport failure — the difference a runtime must not lose.

Timeout

The call did not answer in time.

RateLimited

The provider refused the call and asked the caller to wait.

Fields

retry_after: Option<Duration>

The Retry-After hint, when the provider gave one.

Fail(ProviderError)

Any other normalized failure.

Stream(Vec<StreamEvent>)

Exactly these stream events, in this order.

Chunks(Vec<String>)

This text, delivered in these chunks. Equivalent to a Self::Stream of one text delta per chunk followed by a stop, and shorter to write.

FromSchema(fn(&Value) -> Value)

A document built from the request’s output schema, for a task whose schema depends on its input.

Implementations

impl ScriptedReply

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

Prose.

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

A refusal.

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

What the acknowledge and answer tasks write: a document holding text.

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

An answer the answer task writes.

pub fn cannot_answer(reason: impl Into<String>) -> Self

The answer task saying the facts do not answer the question.

pub fn review_passes() -> Self

A review that passes the reply: each check it was asked answered in its favour.

pub fn review_fails() -> Self

A review that finds the reply claims what its material does not hold.

pub fn rate_limited_after(seconds: u64) -> Self

A rate limit with a Retry-After hint in seconds.

pub fn chunks<I, S>(chunks: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

A text answer split into chunks.

pub const fn label(&self) -> &'static str

Stable snake-case label of the variant, safe in a failure message: it never carries the scripted value.

Trait Implementations

impl Clone for ScriptedReply

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 ScriptedReply

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

Formats the value using the given formatter.