Function resolve_provider_route

crates/openshell-server/src/inference.rs:658–758

(
    provider: &Provider,
    model_id: &str,
)

}

fn resolve_provider_route(
    provider: &Provider,
    model_id: &str,
) -> Result<ResolvedProviderRoute, Status> {
    let raw_provider_type = provider.r#type.trim();
    let provider_type = normalize_provider_type(raw_provider_type)
        .map_or_else(|| raw_provider_type.to_ascii_lowercase(), str::to_string);

    let profile = openshell_core::inference::profile_for(&provider_type).ok_or_else(|| {
        Status::invalid_argument(format!(
            "provider '{name}' has unsupported type '{raw_provider_type}' for cluster inference \
                 (supported: openai, anthropic, nvidia, deepinfra, google-vertex-ai, aws-bedrock)",
            name = provider.object_name()
        ))
    })?;

    // Profiles with `auth: None` are bridge-fronted — the upstream
    // authenticates itself, so the router doesn't need a credential at
    // route-resolution time. Today this is `aws-bedrock`.
    let api_key = if matches!(profile.auth, openshell_core::inference::AuthHeader::None) {
        String::new()
    } else {
        find_provider_api_key(
            provider,
            profile.credential_key_names,
            if provider_type == "google-vertex-ai" {
                CredentialLookup::PreferredOnly
            } else {
                CredentialLookup::PreferredThenAny
            },
        )
        .ok_or_else(|| {
            Status::invalid_argument(format!(
                "provider '{name}' has no usable API key credential",
                name = provider.object_name()
            ))
        })?
    };

    // Vertex AI requires a model-aware URL; delegate to specialised resolver.
    if provider_type == "google-vertex-ai" {
        let route = resolve_vertex_ai_route(
            &provider.config,
            model_id,
            provider.object_name(),
            &api_key,
            profile,
        )?;
        return Ok(ResolvedProviderRoute {
            provider_type,
            route,
        });
    }

    // AWS Bedrock encodes the model in the URL path
    // (`/model/<id>/invoke`), so the model id is interpolated directly
    // into a path segment by the router. Validate up front so the route
    // store cannot hold a model id that would produce ambiguous or