Struct Warmed 

pub struct Warmed<C> { /* private fields */ }

The door a run’s requests enter the keep-warm account by: it owns the adapter a run calls and is itself the Model the turn loop is handed, so every request that reached the provider is recorded without the turn loop knowing keep-warm exists.

The clock is the caller’s, injected from the one sampling point; the round trip it measures around each call is the lead the next renewal leaves with, so the lead follows the provider this door reaches.

Implementations

impl<C: FnMut() -> Result<TimeMs, AxError>> Warmed<C>

pub fn new( model: Box<dyn Model + Send>, setting: KeepWarm, clock: C, ) -> Warmed<C>

Wraps model; under KeepWarm::Off it only forwards.

pub fn next_due(&self) -> Option<u64>

See Warmth::next_due.

pub fn renew_due(&mut self, now_ms: u64) -> Result<Vec<ModelReturn>, AxError>

Sends every renewal due by now_ms through the adapter this door owns; see Warmth::renew_due.

Errors

The model’s failure, unchanged.

Trait Implementations

impl<C: FnMut() -> Result<TimeMs, AxError>> Model for Warmed<C>

fn provider_account(&self) -> Option<ProviderAccountBinding>

The non-secret identity recorded before each actual request: the roster’s provider and current account, answered without asking the vault.

fn account_roster(&self) -> Option<AccountRoster>

The accounts this adapter can call as; None for an adapter with no named account. With two accounts or more each entry’s usable asks the vault, so a caller asks once per round.

fn select_account(&mut self, account: &ServerLabel)

Selects the account every later request of this adapter uses, without sending a request; a name outside the roster leaves the selection as it was. The credential is redeemed at call time, so selecting cannot fail.

fn call(&mut self, req: &ModelRequest<'_>) -> Result<ModelReturn, AxError>

fn call_streaming( &mut self, req: &ModelRequest<'_>, onto: Increments<'_>, ) -> Result<ModelReturn, AxError>

The same call, reporting text as it arrives.

fn call_speculating( &mut self, req: &ModelRequest<'_>, onto: &mut dyn FnMut(&Increment), _early: &mut dyn FnMut(&ToolCall), ) -> Result<ModelReturn, AxError>

The streaming call, also handing over each tool call as soon as it is complete.