Function _build_selector_preview

uncommon_route/proxy.py:3057–3156

(body: dict[str, Any], request: Request)

        )

    def _build_selector_preview(body: dict[str, Any], request: Request) -> dict[str, Any]:
        model = str(body.get("model") or "").strip().lower()
        routing_mode = routing_mode_from_model(model)
        if routing_mode is None:
            return {
                "virtual": False,
                "requested_model": model,
                "served_model": model,
                "reasoning": "passthrough",
                "selector": _selector_state(),
            }

        prompt, system_prompt, max_tokens = _extract_prompt(body)
        step_type, tool_names = _classify_step(body)
        routing_features = _extract_routing_features(
            body,
            step_type=step_type,
            tool_names=tool_names,
            prompt=prompt,
            max_output_tokens=max_tokens,
            session_id=_resolve_session_id(request, body),
        )
        routing_features = _routing_features_with_quality_context(
            routing_features,
            api_format="openai",
            endpoint_name="chat_completions",
            session_id=_resolve_session_id(request, body),
            has_tools=bool(body.get("tools") or body.get("customTools")),
        )
        ctx_features = extract_context_features(body, step_type, prompt)
        user_keyed = _providers.keyed_models() or None
        base_available_models = _mapper.routable_models if _mapper.discovered else list(DEFAULT_MODEL_PRICING.keys())
        if user_keyed:
            base_available_models = _merge_available_models(base_available_models, sorted(user_keyed))
        available_models = _circuit_breaker.filter_available(base_available_models)
        decision = route(
            prompt,
            system_prompt,
            max_tokens,
            config=_routing_config,
            routing_mode=routing_mode,
            routing_features=routing_features,
            user_keyed_models=user_keyed,
            model_experience=_model_experience,
            route_confidence_calibrator=_route_confidence,
            context_features=ctx_features,
            pricing=_get_pricing(),
            available_models=available_models or None,
            model_capabilities=_routing_config.model_capabilities,
            messages=body.get("messages"),
            record_lifecycle=False,
        )
        reasoning = decision.reasoning

        effective_requirements = decision.routing_features.request_requirements()
        effective_hints = decision.routing_features.workload_hints()

        return {