Struct SmartRouter 

pub struct SmartRouter { /* private fields */ }

A smart router that combines keyword matching, capability scoring, and prompt complexity analysis to select the optimal backend.

Routing strategy (evaluated in order):

1. Priority overrides — explicit (keyword, backend) pairs checked first. If a keyword matches the prompt and the backend is available, it wins immediately.

2. Prompt complexity analysis — the prompt is scored for length, code presence, and technical depth. Each complexity level maps to a preferred backend.

3. Capability fallback — an embedded CapabilityRouter scores remaining candidates on cost/latency when neither keywords nor complexity produce a match.

Example

use agent_teams::backend::router::SmartRouter;
use agent_teams::BackendType;

let router = SmartRouter::new(BackendType::ClaudeCode)
    .priority("security audit", BackendType::ClaudeCode)
    .priority("quick fix", BackendType::Codex)
    .simple_backend(BackendType::GeminiCli)
    .complex_backend(BackendType::ClaudeCode)
    .complexity_threshold(200, 800)
    .cost_weight(0.6);

Implementations

impl SmartRouter

pub fn new(default: BackendType) -> Self

Create a new smart router with a default backend.

pub fn priority(self, keyword: impl Into<String>, backend: BackendType) -> Self

Add a priority keyword override.

Priority keywords use word-boundary matching (same semantics as [KeywordRouter::word_boundary(true)]). The first matching priority wins.

pub fn simple_backend(self, backend: BackendType) -> Self

Set the preferred backend for simple (short, non-technical) prompts.

pub fn medium_backend(self, backend: BackendType) -> Self

Set the preferred backend for medium-complexity prompts.

pub fn complex_backend(self, backend: BackendType) -> Self

Set the preferred backend for complex (long, code-heavy) prompts.

pub fn complexity_threshold(self, simple: usize, complex: usize) -> Self

Set the character-length thresholds for complexity classification.

• Prompts shorter than simple characters are Simple.
• Prompts longer than complex characters are Complex.
• Everything in between is Medium.

Defaults: simple = 200, complex = 800.

Panics

Panics in debug mode if simple >= complex.

pub fn cost_weight(self, weight: f32) -> Self

Set the cost vs latency weight for the capability fallback (0.0–1.0).

pub fn require_multi_turn(self, require: bool) -> Self

Require multi-turn support in the capability fallback.

pub fn with_capability( self, backend: BackendType, cap: BackendCapability, ) -> Self

Override capability data for a backend in the fallback scorer.

pub fn analyze_complexity(&self, prompt: &str) -> PromptComplexity

Analyze a prompt and return its complexity level.

Trait Implementations

impl BackendRouter for SmartRouter

fn route<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, config: &'life1 SpawnConfig, available: &'life2 [BackendType], ) -> Pin<Box<dyn Future<Output = Option<BackendType>> + Send + 'async_trait>>

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

Choose the optimal backend for the given config.

impl Debug for SmartRouter

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

Formats the value using the given formatter.