Struct Attempt 

pub struct Attempt {
    pub style: PromptStyle,
    pub cache_ttl: CacheTtl,
    pub progress: Option<Arc<dyn Progress>>,
    pub format: &'static dyn Adapter,
    pub present: PresentContext,
}

The coded skill.

Everything its decisions depend on — the bundle, the policy’s command prefixes and the limits — arrives in the run’s input, so it is journaled and strict replay needs no configuration. Only the prompt dialect is construction-time, and it is part of each model call’s effect key.

Fields

style: PromptStyle

Prompt dialect.

cache_ttl: CacheTtl

Cache breakpoint lifetime.

progress: Option<Arc<dyn Progress>>

Where live progress goes; not journaled, None in replay.

format: &'static dyn Adapter

The project’s spec format.

present: PresentContext

The sandbox, as a person asked about a command is told; live only.

Trait Implementations

impl Debug for Attempt

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

Formats the value using the given formatter.

impl Skill for Attempt

fn descriptor(&self) -> SkillDescriptor

fn invoke<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, cx: &'life1 mut StepCtx<'life2>, input: Tainted<Value>, ) -> Pin<Box<dyn Future<Output = Result<Outcome, SkillError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn compensation(&self) -> Compensation

This step’s place in the saga.

fn compensate<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _cx: &'life1 mut StepCtx<'life2>, _output: &'life3 Tainted<Value>, ) -> Pin<Box<dyn Future<Output = Result<(), SkillError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Undo this step, because a later one failed.