Struct RouterProvider 

pub struct RouterProvider { /* private fields */ }

Multi-model router — routes requests to different provider+model combos based on a task hint encoded in the model parameter.

The model parameter can be:

• A regular model name (e.g. “anthropic/claude-sonnet-4”) → uses default provider
• A hint-prefixed string (e.g. “hint:reasoning”) → resolves via route table

This wraps multiple pre-created providers and selects the right one per request.

Implementations

impl RouterProvider

pub fn new( providers: Vec<(String, Box<dyn Provider>)>, routes: Vec<(String, Route)>, default_model: String, ) -> Self

Create a new router with a default provider and optional routes.

providers is a list of (name, provider) pairs. The first one is the default. routes maps hint names to Route structs containing provider_name and model.

pub fn resolve_cost_optimized( &self, model: &str, prices: &HashMap<String, ModelPricing>, required_vision: bool, required_tools: bool, ) -> (usize, String)

Resolve a model parameter to the cheapest qualifying route based on pricing.

If the model starts with "hint:cost-optimized" or "hint:cheapest", this method scores each route by input_price + output_price (a simple proxy for total cost), optionally filtering by capability requirements, and returns the cheapest qualifying route.

Falls back to the default route when no pricing data matches.

Trait Implementations

impl Provider for RouterProvider

fn chat_with_system<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, system_prompt: Option<&'life1 str>, message: &'life2 str, model: &'life3 str, temperature: f64, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

One-shot chat with optional system prompt.

fn chat_with_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, messages: &'life1 [ChatMessage], model: &'life2 str, temperature: f64, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

Multi-turn conversation. Default implementation extracts the last user message and delegates to chat_with_system.

fn chat<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, request: ChatRequest<'life1>, model: &'life2 str, temperature: f64, ) -> Pin<Box<dyn Future<Output = Result<ChatResponse>> + Send + 'async_trait>>

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

Structured chat API for agent loop callers.

fn chat_with_tools<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, messages: &'life1 [ChatMessage], tools: &'life2 [Value], model: &'life3 str, temperature: f64, ) -> Pin<Box<dyn Future<Output = Result<ChatResponse>> + Send + 'async_trait>>

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

Chat with tool definitions for native function calling support. The default implementation falls back to chat_with_history and returns an empty tool_calls vector (prompt-based tool use only).

fn supports_native_tools(&self) -> bool

Whether provider supports native tool calls over API.

fn supports_streaming(&self) -> bool

Whether provider supports streaming responses. Default implementation returns false.

fn supports_streaming_tool_events(&self) -> bool

Whether provider can emit structured tool-call stream events.

fn stream_chat_with_history( &self, messages: &[ChatMessage], model: &str, temperature: f64, options: StreamOptions, ) -> BoxStream<'static, StreamResult<StreamChunk>>

Streaming chat with history. Default implementation extracts the last user message and delegates to stream_chat_with_system, mirroring the non-streaming chat_with_history.

fn stream_chat( &self, request: ChatRequest<'_>, model: &str, temperature: f64, options: StreamOptions, ) -> BoxStream<'static, StreamResult<StreamEvent>>

Structured streaming chat interface.

fn supports_vision(&self) -> bool

Whether provider supports multimodal vision input.

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

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

Warm up the HTTP connection pool (TLS handshake, DNS, HTTP/2 setup). Default implementation is a no-op; providers with HTTP clients should override.

fn capabilities(&self) -> ProviderCapabilities

Query provider capabilities.

fn convert_tools(&self, tools: &[ToolSpec]) -> ToolsPayload

Convert tool specifications to provider-native format.

fn simple_chat<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, message: &'life1 str, model: &'life2 str, temperature: f64, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

Simple one-shot chat (single user message, no explicit system prompt).

fn stream_chat_with_system( &self, _system_prompt: Option<&str>, _message: &str, _model: &str, _temperature: f64, _options: StreamOptions, ) -> BoxStream<'static, StreamResult<StreamChunk>>

Streaming chat with optional system prompt. Returns an async stream of text chunks. Default implementation falls back to non-streaming chat.