Struct MultiProvider 

pub struct MultiProvider { /* private fields */ }

Intelligent routing provider with fallback support.

MultiProvider implements the Provider trait and provides automatic model selection based on task complexity, with circuit breaker protection and ordered fallback for resilience.

Type Parameters

• R: The complexity router type (default: DefaultRouter)
• F: The fallback chain type (default: FallbackChain)

Implementations

impl MultiProvider

pub fn new(config: MultiProviderConfig) -> Self

Create a new MultiProvider with the given configuration.

Uses DefaultRouter for complexity-based routing.

Example

let config = MultiProviderConfig::default();
let provider = MultiProvider::new(config);

pub fn with_router(router: impl ComplexityRouter + 'static) -> Self

Create a new MultiProvider with a custom router.

Allows using a custom implementation of ComplexityRouter.

Example

let router = MyCustomRouter::new();
let provider = MultiProvider::with_router(router);

pub fn with_config_and_router( config: MultiProviderConfig, router: impl ComplexityRouter + 'static, ) -> Self

Create a new MultiProvider with custom config and router.

Example

let config = MultiProviderConfig::default()
    .with_auto_routing(false)
    .with_max_retries(2);
let router = DefaultRouter::new();
let provider = MultiProvider::with_config_and_router(config, router);

pub fn set_router(self, router: impl ComplexityRouter + 'static) -> Self

Replace the router with a new implementation.

Example

let provider = multi_provider.set_router(new_router);

pub fn with_fallback(self, fallback: FallbackChain) -> Self

Set the fallback chain.

The fallback chain is used when the primary model fails or is unavailable.

Example

let fallback = FallbackChain::from_ids(&["anthropic/claude-sonnet-4"])?;
let provider = multi_provider.with_fallback(fallback);

pub fn set_fallback(&mut self, fallback: FallbackChain)

Set the fallback chain by reference.

pub fn register_provider(&mut self, name: &str, provider: Arc<dyn Provider>)

Register a provider with this MultiProvider.

The provider can be referenced by name when calling stream(). Each provider gets its own circuit breaker instance.

Arguments

• name - Provider identifier (e.g., “openai”, “anthropic”)
• provider - The provider implementation

Example

let openai_provider = Arc::new(OpenAiProvider::new());
multi_provider.register_provider("openai", openai_provider);

pub fn unregister_provider(&mut self, name: &str) -> bool

Unregister a provider.

Removes the provider and its associated circuit breaker.

Arguments

• name - Provider identifier to remove

Returns

true if the provider was found and removed.

pub fn get_provider(&self, name: &str) -> Option<&Arc<dyn Provider>>

Get a provider by name.

Arguments

• name - Provider identifier

Returns

Option containing the provider if found.

pub fn get_breaker( &self, provider_name: &str, ) -> Option<Arc<ProviderCircuitBreaker>>

Get the circuit breaker for a provider.

Arguments

• provider_name - Provider identifier

Returns

Arc<ProviderCircuitBreaker> if the provider is registered.

pub fn provider_names(&self) -> Vec<&str>

Get all registered provider names.

pub fn circuit_breaker_diagnostics(&self) -> Vec<CircuitBreakerDiagnostics>

Get diagnostic information for all circuit breakers.

Returns

Vector of diagnostics for each registered provider.

pub fn router(&self) -> &Arc<dyn ComplexityRouter>

Get the router used for complexity-based routing.

pub fn fallback(&self) -> &FallbackChain

Get a reference to the fallback chain.

pub fn config(&self) -> &MultiProviderConfig

Get a reference to the configuration.

pub fn diagnostics(&self) -> MultiProviderDiagnostics

Get diagnostic summary of the multi-provider state.

Trait Implementations

impl Provider for MultiProvider

fn stream<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, model: &'life1 Model, context: &'life2 Context, options: Option<StreamOptions>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = ProviderEvent> + Send>>, ProviderError>> + Send + 'async_trait>>

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

Stream assistant message events with intelligent routing.

This method implements the priority order logic:

1. If auto_routing=true: classify complexity and select router’s best model
2. Try the incoming model (if registered and circuit breaker allows)
3. Try fallback chain models in order

For each candidate model:

• Check circuit breaker (skip if open)
• Call provider.stream()
• On retryable error: record failure, retry or move to next
• On non-retryable error: return immediately
• On success: record success to breaker, return stream

fn name(&self) -> &str

Returns “multi-provider” as the provider name.