Struct Fallback 

pub struct Fallback<A, B> { /* private fields */ }

Try primary; on a failure another provider might survive, try secondary.

use io_harness::provider::Fallback;
use io_harness::{Anthropic, OpenRouter};

let provider = Fallback::new(OpenRouter::from_env()?, Anthropic::from_env()?);

Implementations

impl<A: Provider, B: Provider> Fallback<A, B>

pub fn new(primary: A, secondary: B) -> Self

secondary answers when primary fails in a way it might survive.

Trait Implementations

impl<A: Debug, B: Debug> Debug for Fallback<A, B>

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

Formats the value using the given formatter.

impl<A: Provider + Sync, B: Provider + Sync> Provider for Fallback<A, B>

fn accepts_images(&self) -> bool

Available on crate feature media only.

Both, or neither. Reporting the primary’s answer would let an image reach a secondary that cannot read it on the one call that matters — the fallover — and a fallover already means something has gone wrong. The secondary would refuse it (ensure_media_accepted runs inside every built-in provider too), so the only thing the conjunction changes is when the caller finds out: before the run, rather than mid-fallover.

fn endpoint(&self) -> Option<&str>

The primary’s, for the single-endpoint callers that predate fallback. endpoints is what authorization uses.

fn endpoints(&self) -> Vec<&str>

BOTH providers’ endpoints.

This is the reason endpoints exists at all. The 0.8.0 egress policy is deny-by-default and a run authorizes its provider’s host before its first step; a combinator that reported only the primary’s host would leave the secondary’s completely ungoverned, so a fallback would be a way to reach a host the policy never saw.

fn last_served(&self) -> Option<String>

The LEAF that answered, not the branch it sits in.

A nested Fallback::new(a, Fallback::new(b, c)) whose c answered must record "c", not "b -> c": the row exists because one label for a whole run stops being true the moment a run can use two, and naming a sub-chain reintroduces exactly that ambiguity one level down.

async fn complete( &self, request: CompletionRequest, ) -> Result<CompletionResponse>

Perform one completion.

fn name(&self) -> &str

A short label recorded in the run’s trace so an audit shows which provider ran. Defaults to "provider" so existing implementers keep compiling; the built-in providers override it.