Struct DrawOnAuthority 

pub struct DrawOnAuthority { /* private fields */ }

Drawing on a standing authority, as an effect.

Why this cannot be a plain call

The remaining balance is mutable state outside the journal. A skill that read it inside the deterministic zone would make replay depend on what the store happens to hold now: a run replayed after a later draw would see a different balance, take a different branch, and produce a history that disagrees with itself. Journaling the draw makes the receipt part of the record, so replay reads what the run actually got.

The key it deduplicates on is dispatch, not effect

Provenance::effect hashes the attempt number, so a retry carries a different key — which is right for the journal and exactly wrong here. Two attempts at one draw must consume the authority once, so the store is keyed on Provenance::dispatch, the identifier the crate defines as stable across retries of the same call. Getting this backwards spends a customer’s authorization twice for one purchase, and only under retry, which is the hardest condition to notice in testing.

Trait Implementations

impl Clone for DrawOnAuthority

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 DrawOnAuthority

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

Formats the value using the given formatter.

impl Effect for DrawOnAuthority

fn mutates(&self) -> bool

It changes durable state that authorizes spending, and says so to every rule reading context.mutates. The id it draws on is checked before this effect exists: StepCtx::draw refuses one untrusted data chose.

fn recovery(&self) -> Recovery

Safe to repeat, because the store deduplicates on the dispatch key and returns the original receipt. Without that idempotence this would have to be Reconcile, and every interrupted draw would wake an operator.

type Output = Drawn

What comes back. Must round-trip through JSON: replay reconstructs it from the journal rather than from the driver.

fn descriptor(&self) -> EffectDescriptor

What this effect does. Hashed (with position) into the effect key.

fn attach(&mut self, provenance: &Provenance)

Receive the run-scoped provenance for this call.

fn perform<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, EffectError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Do the thing. Called at most once per key per run; never called during replay.

fn gen_ai_operation(&self) -> Option<&'static str>

Which OpenTelemetry GenAI operation this effect is, if it is one.

fn gen_ai_request(&self) -> Option<GenAiRequest>

Who this operation asks, and for what — the request half of the GenAI span attributes.

fn gen_ai_response(&self, output: &Self::Output) -> Option<GenAiResponse>

What came back, split the way the convention reports it.

fn retry(&self) -> RetryPolicy

How many times to repeat this effect when it fails, and how far apart.

fn retries_landed(&self) -> bool

Whether a failure that landed may be tried again, within retry.

fn max_sensitivity(&self) -> Sensitivity

The highest data sensitivity this sink may receive.

fn sink_arguments(&self) -> Option<&Value>

The exact value this effect will send to its sink.

fn rebind(&mut self, _arguments: Value) -> bool

Bind arguments in place of the ones this effect was built over, where it can — what a declared redaction at a sink needs.

fn outbound_bytes(&self) -> u64

How many bytes dispatching this effect sends out of the plane.

fn credential_binding(&self) -> Option<CredentialBinding>

Whom the credential this effect presents names, for an effect that presents one to another party.

fn protected_fields(&self) -> &[ProtectedField]

Field-specific source and sensitivity rules for a structured sink.

fn delegation_depth(&self) -> Option<usize>

The resulting delegation depth when this effect hands authority onward.

fn source(&self) -> SourceId

The provenance identity an untrusted result of this effect carries.

fn trust(&self) -> Trust

How much this effect’s output may be trusted.

fn output_sensitivity(&self) -> Sensitivity

How sensitive this effect’s output is, at minimum.

fn spend(&self, _output: &Self::Output) -> Spend

What this effect consumed.

fn reconcile<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Reconciliation<Self::Output>, EffectError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Ask the provider whether a call landed.