use std::collections::HashMap;
use std::sync::{LazyLock, Mutex};
use axum::extract::Query;
use axum::http::{header, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::Json;
use serde::{Deserialize, Serialize};
use super::AppError;
use crate::cmd::search::{self, Hit, ModelCard, DEFAULT_LIMIT, MAX_LIMIT};
#[derive(Deserialize)]
pub(super) struct SearchParams {
#[serde(default)]
q: String,
limit: Option<u32>,
}
#[derive(Serialize)]
pub(super) struct SearchResponse {
models: Vec<Hit>,
}
pub(super) async fn handle_search(
Query(params): Query<SearchParams>,
) -> Result<Json<SearchResponse>, AppError> {
let query = params.q.trim();
if query.is_empty() {
return Err(AppError::status(
StatusCode::BAD_REQUEST,
"search query `q` must not be empty",
));
}
let limit = params.limit.unwrap_or(DEFAULT_LIMIT).clamp(1, MAX_LIMIT);
let models = search::search(query, limit, None)
.await
.map_err(|e| AppError(e, StatusCode::BAD_GATEWAY))?;
Ok(Json(SearchResponse { models }))
}
#[derive(Deserialize)]
pub(super) struct PopularParams {
limit: Option<u32>,
}
pub(super) async fn handle_popular(
Query(params): Query<PopularParams>,
) -> Result<Json<SearchResponse>, AppError> {
let limit = params.limit.unwrap_or(DEFAULT_LIMIT).clamp(1, MAX_LIMIT);
let models = search::popular(limit)
.await
.map_err(|e| AppError(e, StatusCode::BAD_GATEWAY))?;
Ok(Json(SearchResponse { models }))
}
#[derive(Deserialize)]
pub(super) struct NameParam {
#[serde(default)]
name: String,
}
pub(super) async fn handle_model(
Query(params): Query<NameParam>,
) -> Result<Json<ModelCard>, AppError> {
let name = params.name.trim();
if name.is_empty() {
return Err(AppError::status(
StatusCode::BAD_REQUEST,
"`name` must not be empty",
));
}
let card = search::model_card(name)
.await
.map_err(|e| AppError(e, StatusCode::BAD_GATEWAY))?;
Ok(Json(card))
}
static AVATARS: LazyLock<Mutex<HashMap<String, Option<String>>>> = LazyLock::new(Default::default);
const AVATARS_KEPT: usize = 4096;
pub(super) async fn handle_avatar(Query(params): Query<NameParam>) -> Response {
let key = params
.name
.rsplit_once('/')
.map(|(o, _)| o.to_owned())
.unwrap_or_default();
let cached = AVATARS.lock().unwrap().get(&key).cloned();
let url = match cached {
Some(url) => url,
None => match search::avatar(¶ms.name).await {
Ok(url) => {
let mut avatars = AVATARS.lock().unwrap();
if avatars.len() >= AVATARS_KEPT {
avatars.clear();
}
avatars.insert(key, url.clone());
url
}
Err(_) => None,
},
};
match url {
Some(url) => (
StatusCode::FOUND,
[
(header::LOCATION, url),
(header::CACHE_CONTROL, "max-age=86400".into()),
],
)
.into_response(),
None => StatusCode::NOT_FOUND.into_response(),
}
}
#[cfg(test)]
mod tests {
use super::super::test_support::{serve_router, test_state};
#[tokio::test]
async fn an_empty_query_is_a_bad_request() {
let url = serve_router(test_state()).await;
for query in ["", "?q=", "?q=%20%20"] {
let r = reqwest::get(format!("{url}/llmman/search{query}"))
.await
.unwrap();
assert_eq!(r.status(), reqwest::StatusCode::BAD_REQUEST, "{query}");
let body: serde_json::Value = r.json().await.unwrap();
assert!(
body["error"].as_str().unwrap().contains("`q`"),
"{query}: {body}"
);
}
}
#[test]
fn a_hit_serializes_with_its_reference_and_nullable_counts() {
let hit = crate::cmd::search::Hit {
name: "hf.co/unsloth/Qwen3.5-0.8B-GGUF".into(),
pulls: None,
likes: Some(7),
updated: Some("2026-09-01T00:00:00Z".into()),
};
assert_eq!(
serde_json::to_value(super::SearchResponse { models: vec![hit] }).unwrap(),
serde_json::json!({"models": [{
"name": "hf.co/unsloth/Qwen3.5-0.8B-GGUF",
"pulls": null,
"likes": 7,
"updated": "2026-09-01T00:00:00Z",
}]})
);
}
}