Function select_from_pool

uncommon_route/router/selector.py:1247–1729

Select the best model from the full discovered pool. Unlike ``select_model`` which picks from a per-tier list, this evaluates ALL available models and lets ``complexity`` drive the cost-vs-quality trade-off via weight interpolation.

(
    complexity: float,
    mode: RoutingMode,
    confidence: float,
    reasoning_text: str,
    available_models: list[str],
    estimated_input_tokens: int,
    max_output_tokens: int,
    prompt: str,
    pricing: dict[str, ModelPricing],
    capabilities: dict[str, ModelCapabilities],
    requirements: RequestRequirements,
    constraints: RoutingConstraints | None = None,
    workload_hints: WorkloadHints | None = None,
    routing_features: RoutingFeatures | None = None,
    answer_depth: AnswerDepth = AnswerDepth.STANDARD,
    answer_depth_multiplier: float = 1.0,
    agentic_score: float = 0.0,
    user_keyed_models: set[str] | None = None,
    selection_weights: SelectionWeights | None = None,
    bandit_config: BanditConfig | None = None,
    model_experience: object | None = None,
    raw_confidence: float | None = None,
    confidence_source: str = "classifier",
    calibration_version: str = "",
    calibration_sample_count: int = 0,
    calibration_temperature: float = 1.0,
    calibration_applied_tags: tuple[str, ...] = (),
)

def select_from_pool(
    complexity: float,
    mode: RoutingMode,
    confidence: float,
    reasoning_text: str,
    available_models: list[str],
    estimated_input_tokens: int,
    max_output_tokens: int,
    prompt: str,
    pricing: dict[str, ModelPricing],
    capabilities: dict[str, ModelCapabilities],
    requirements: RequestRequirements,
    constraints: RoutingConstraints | None = None,
    workload_hints: WorkloadHints | None = None,
    routing_features: RoutingFeatures | None = None,
    answer_depth: AnswerDepth = AnswerDepth.STANDARD,
    answer_depth_multiplier: float = 1.0,
    agentic_score: float = 0.0,
    user_keyed_models: set[str] | None = None,
    selection_weights: SelectionWeights | None = None,
    bandit_config: BanditConfig | None = None,
    model_experience: object | None = None,
    raw_confidence: float | None = None,
    confidence_source: str = "classifier",
    calibration_version: str = "",
    calibration_sample_count: int = 0,
    calibration_temperature: float = 1.0,
    calibration_applied_tags: tuple[str, ...] = (),
) -> RoutingDecision:
    """Select the best model from the full discovered pool.

    Unlike ``select_model`` which picks from a per-tier list, this
    evaluates ALL available models and lets ``complexity`` drive the
    cost-vs-quality trade-off via weight interpolation.
    """
    weights = selection_weights or SelectionWeights()
    bc = bandit_config or BanditConfig()
    hard_constraints = constraints or RoutingConstraints()
    hints = workload_hints or WorkloadHints()
    tier = _derive_tier(complexity)
    effective_features = routing_features or RoutingFeatures()
    step_stable = _stabilize_agent_step_selection(effective_features)
    if step_stable and bc.enabled:
        bc = replace(bc, enabled=False)
    lane = request_capability_lane(effective_features)

    if not available_models:
        _raise_no_available_models()

    filtered_candidates, excluded = _filter_candidates(
        available_models, requirements, capabilities)
    if not filtered_candidates:
        _raise_capability_infeasible(
            available_models=available_models,
            candidate_count=len(available_models),
            requirements=requirements,
            excluded=excluded,
            constraints=hard_constraints,