Struct RouterModelProvider 

pub struct RouterModelProvider { /* private fields */ }

Multi-model router — routes requests to different model_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 model_provider
• A hint-prefixed string (e.g. “hint:reasoning”) → resolves via route table

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

Implementations

impl RouterModelProvider

pub fn new( alias: &str, model_providers: Vec<(String, Box<dyn ModelProvider>)>, routes: Vec<(String, Route)>, default_model: String, ) -> Self

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

model_providers is a list of (name, model_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, model_provider_pricing: &HashMap<String, HashMap<String, f64>>, 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 Attributable for RouterModelProvider

fn role(&self) -> Role

fn alias(&self) -> &str

impl ModelProvider for RouterModelProvider

fn chat_with_system<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, system_prompt: Option<&'life1 str>, message: &'life2 str, model: &'life3 str, temperature: Option<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. See simple_chat for the temperature contract.

fn chat_with_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, messages: &'life1 [ChatMessage], model: &'life2 str, temperature: Option<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. See simple_chat for the temperature contract.

fn chat<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, request: ChatRequest<'life1>, model: &'life2 str, temperature: Option<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. See simple_chat for the temperature contract.

fn chat_with_tools<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, messages: &'life1 [ChatMessage], tools: &'life2 [Value], model: &'life3 str, temperature: Option<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. See simple_chat for the temperature contract.

fn supports_native_tools(&self) -> bool

Whether model_provider supports native tool calls over API.

fn supports_streaming(&self) -> bool

Whether model_provider supports streaming responses.

fn supports_streaming_tool_events(&self) -> bool

Whether model_provider can emit structured tool-call stream events.

fn stream_chat_with_system( &self, system_prompt: Option<&str>, message: &str, model: &str, temperature: Option<f64>, options: StreamOptions, ) -> BoxStream<'static, StreamResult<StreamChunk>>

Streaming chat with optional system prompt. See simple_chat for the temperature contract.

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

Streaming chat with history. See simple_chat for the temperature contract.

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

Structured streaming chat interface. See simple_chat for the temperature contract.

fn supports_vision(&self) -> bool

Whether model_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.

fn capabilities(&self) -> ProviderCapabilities

Query model_provider capabilities.

fn default_temperature(&self) -> f64

Temperature used when the caller passes None. Override per family.

fn default_max_tokens(&self) -> u32

Max output tokens used when the caller / config doesn’t set one.

fn default_timeout_secs(&self) -> u64

HTTP timeout (seconds) used when the caller / config doesn’t set one.

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

Canonical public API endpoint, when there is one. Returned as a string slice so model_provider impls can serve from const &'static strs without allocations. None = model_provider has no universal endpoint (local model_providers, auth-less CLIs, user-BYO endpoints).

fn default_wire_api(&self) -> &str

Wire protocol variant. Either "responses" (OpenAI Codex-style) or "chat_completions" (everything else). Providers override to their native format.

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: Option<f64>, ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'async_trait>>

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

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

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

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

Fetch the list of available model IDs for this model_provider.