Function resolve_route_by_name

crates/openshell-server/src/inference.rs:933–986

(
    store: &Store,
    route_name: &str,
)

}

async fn resolve_route_by_name(
    store: &Store,
    route_name: &str,
) -> Result<Option<ResolvedRoute>, Status> {
    let route = store
        .get_message_by_name::<InferenceRoute>(route_name)
        .await
        .map_err(|e| Status::internal(format!("fetch route failed: {e}")))?;

    let Some(route) = route else {
        return Ok(None);
    };

    let Some(config) = route.config.as_ref() else {
        return Ok(None);
    };

    if config.provider_name.trim().is_empty() {
        return Err(Status::failed_precondition(format!(
            "route '{route_name}' is missing provider_name"
        )));
    }

    if config.model_id.trim().is_empty() {
        return Err(Status::failed_precondition(format!(
            "route '{route_name}' is missing model_id"
        )));
    }

    let provider = store
        .get_message_by_name::<Provider>(&config.provider_name)
        .await
        .map_err(|e| Status::internal(format!("fetch provider failed: {e}")))?
        .ok_or_else(|| {
            Status::failed_precondition(format!(
                "configured provider '{}' was not found",
                config.provider_name
            ))
        })?;

    let resolved = resolve_provider_route(&provider, &config.model_id)?;

    Ok(Some(ResolvedRoute {
        name: route_name.to_string(),
        base_url: resolved.route.endpoint,
        model_id: config.model_id.clone(),
        api_key: resolved.route.api_key,
        protocols: resolved.route.protocols,
        provider_type: resolved.provider_type,
        timeout_secs: config.timeout_secs,
        model_in_path: resolved.route.model_in_path,
        request_path_override: resolved.route.request_path_override,
    }))
}

#[cfg(test)]
mod tests {