use std::sync::Arc;
use crate::domain::services::search_service::SearchResult;
#[derive(Debug, Clone, PartialEq)]
pub struct RerankScore {
pub index: usize,
pub score: f32,
}
#[derive(Debug, thiserror::Error)]
pub enum RerankError {
#[error("rerank provider error: {0}")]
Provider(String),
#[error("invalid rerank input: {0}")]
InvalidInput(String),
}
#[async_trait::async_trait]
pub trait RerankProvider: Send + Sync {
async fn rerank(
&self,
query: &str,
documents: &[String],
top_k: Option<usize>,
) -> Result<Vec<RerankScore>, RerankError>;
fn name(&self) -> &str;
}
pub struct FallbackRerankProvider {
primary: Arc<dyn RerankProvider>,
secondary: Arc<dyn RerankProvider>,
}
impl FallbackRerankProvider {
pub fn new(primary: Arc<dyn RerankProvider>, secondary: Arc<dyn RerankProvider>) -> Self {
Self { primary, secondary }
}
}
#[async_trait::async_trait]
impl RerankProvider for FallbackRerankProvider {
async fn rerank(
&self,
query: &str,
documents: &[String],
top_k: Option<usize>,
) -> Result<Vec<RerankScore>, RerankError> {
match self.primary.rerank(query, documents, top_k).await {
Ok(scores) => Ok(scores),
Err(primary_err) => {
log::warn!(
"primary rerank provider failed, falling back to secondary: {primary_err}"
);
self.secondary
.rerank(query, documents, top_k)
.await
.map_err(|secondary_err| {
RerankError::Provider(format!(
"both rerank providers failed; primary: {primary_err}; \
secondary: {secondary_err}"
))
})
}
}
}
fn name(&self) -> &str {
"fallback"
}
}
pub struct SearchReranker {
provider: Option<Arc<dyn RerankProvider>>,
max_documents: usize,
}
impl SearchReranker {
pub fn new(provider: Option<Arc<dyn RerankProvider>>, max_documents: usize) -> Self {
Self {
provider,
max_documents: max_documents.clamp(1, 100),
}
}
pub fn is_enabled(&self) -> bool {
self.provider.is_some()
}
pub fn provider(&self) -> Option<&Arc<dyn RerankProvider>> {
self.provider.as_ref()
}
pub async fn rerank_results(
&self,
query: &str,
results: Vec<SearchResult>,
) -> Vec<SearchResult> {
let Some(provider) = self.provider.as_ref() else {
return results;
};
if results.len() < 2 || query.trim().is_empty() {
return results;
}
let head_len = results.len().min(self.max_documents);
let documents: Vec<String> = results[..head_len].iter().map(result_to_document).collect();
let started = std::time::Instant::now();
let scored = match provider.rerank(query, &documents, Some(head_len)).await {
Ok(scores) => scores,
Err(err) => {
log::warn!(
"search rerank failed (fail-open, keeping original order): \
provider={} results={} err={err}",
provider.name(),
results.len()
);
return results;
}
};
let (reranked, scored_count) = apply_rerank_scores(results, scored, head_len);
log::info!(
"search rerank applied: provider={} docs={head_len} scored={} elapsed_ms={}",
provider.name(),
scored_count,
started.elapsed().as_millis()
);
reranked
}
}
fn apply_rerank_scores(
results: Vec<SearchResult>,
scored: Vec<RerankScore>,
head_len: usize,
) -> (Vec<SearchResult>, usize) {
let mut valid: Vec<(usize, f32)> = scored
.into_iter()
.filter(|s| s.index < head_len)
.map(|s| (s.index, s.score))
.collect();
valid.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
let mut seen = vec![false; head_len];
let mut reranked: Vec<SearchResult> = Vec::with_capacity(results.len());
for (index, score) in &valid {
seen[*index] = true;
let mut item = results[*index].clone();
item.score = Some(*score as f64);
reranked.push(item);
}
for (position, mut item) in results.into_iter().enumerate() {
let scored_here = position < head_len && seen[position];
if !scored_here {
item.score = None;
reranked.push(item);
}
}
(reranked, valid.len())
}
fn result_to_document(result: &SearchResult) -> String {
match result.description.as_deref() {
Some(desc) if !desc.trim().is_empty() => {
format!("{}. {}", result.title.trim(), desc.trim())
}
_ => result.title.trim().to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
struct MockProvider {
fail: bool,
scores: Vec<RerankScore>,
}
#[async_trait::async_trait]
impl RerankProvider for MockProvider {
async fn rerank(
&self,
_query: &str,
_documents: &[String],
_top_k: Option<usize>,
) -> Result<Vec<RerankScore>, RerankError> {
if self.fail {
return Err(RerankError::Provider("mock down".to_string()));
}
Ok(self.scores.clone())
}
fn name(&self) -> &str {
"mock"
}
}
struct FallbackMockProvider {
fail: bool,
calls: std::sync::Arc<std::sync::atomic::AtomicUsize>,
}
#[async_trait::async_trait]
impl RerankProvider for FallbackMockProvider {
async fn rerank(
&self,
_query: &str,
_documents: &[String],
_top_k: Option<usize>,
) -> Result<Vec<RerankScore>, RerankError> {
self.calls
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
if self.fail {
return Err(RerankError::Provider("fallback mock down".to_string()));
}
Ok(vec![RerankScore {
index: 0,
score: 0.9,
}])
}
fn name(&self) -> &str {
"fallback-mock"
}
}
#[tokio::test]
async fn fallback_rerank_primary_success_skips_secondary() {
let primary_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let secondary_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let fallback = FallbackRerankProvider::new(
Arc::new(FallbackMockProvider {
fail: false,
calls: primary_calls.clone(),
}),
Arc::new(FallbackMockProvider {
fail: true,
calls: secondary_calls.clone(),
}),
);
let out = fallback
.rerank("q", &["d".to_string()], None)
.await
.expect("primary ok");
assert_eq!(out.len(), 1);
assert_eq!(primary_calls.load(std::sync::atomic::Ordering::Relaxed), 1);
assert_eq!(
secondary_calls.load(std::sync::atomic::Ordering::Relaxed),
0,
"secondary must not be called when primary succeeds"
);
}
#[tokio::test]
async fn fallback_rerank_primary_failure_switches_once() {
let primary_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let secondary_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let fallback = FallbackRerankProvider::new(
Arc::new(FallbackMockProvider {
fail: true,
calls: primary_calls.clone(),
}),
Arc::new(FallbackMockProvider {
fail: false,
calls: secondary_calls.clone(),
}),
);
let out = fallback
.rerank("q", &["d".to_string()], None)
.await
.expect("secondary ok");
assert_eq!(out[0].score, 0.9);
assert_eq!(primary_calls.load(std::sync::atomic::Ordering::Relaxed), 1);
assert_eq!(
secondary_calls.load(std::sync::atomic::Ordering::Relaxed),
1
);
}
#[tokio::test]
async fn fallback_rerank_both_fail_reports_both_contexts() {
let fallback = FallbackRerankProvider::new(
Arc::new(FallbackMockProvider {
fail: true,
calls: std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)),
}),
Arc::new(FallbackMockProvider {
fail: true,
calls: std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)),
}),
);
let err = fallback
.rerank("q", &["d".to_string()], None)
.await
.expect_err("must error");
let rendered = err.to_string();
assert!(
rendered.contains("both rerank providers failed"),
"{rendered}"
);
assert!(rendered.contains("fallback mock down"), "{rendered}");
}
fn result(title: &str, description: Option<&str>) -> SearchResult {
SearchResult {
title: title.to_string(),
url: format!("https://example.org/{title}"),
description: description.map(str::to_string),
engine: "mock".to_string(),
score: None,
}
}
#[tokio::test]
async fn test_disabled_reranker_passthrough() {
let reranker = SearchReranker::new(None, 25);
assert!(!reranker.is_enabled());
let results = vec![result("a", None), result("b", None)];
let out = reranker.rerank_results("q", results.clone()).await;
assert_eq!(out.len(), 2);
assert!(out.iter().all(|r| r.score.is_none()));
}
#[tokio::test]
async fn test_single_result_short_circuits() {
let reranker = SearchReranker::new(
Some(Arc::new(MockProvider {
fail: false,
scores: vec![RerankScore {
index: 0,
score: 0.9,
}],
})),
25,
);
let out = reranker
.rerank_results("q", vec![result("only", None)])
.await;
assert_eq!(out.len(), 1);
assert!(
out[0].score.is_none(),
"single result must not be re-scored"
);
}
#[tokio::test]
async fn test_reorder_by_score_desc() {
let reranker = SearchReranker::new(
Some(Arc::new(MockProvider {
fail: false,
scores: vec![
RerankScore {
index: 0,
score: 0.1,
},
RerankScore {
index: 1,
score: 0.9,
},
RerankScore {
index: 2,
score: 0.7,
},
],
})),
25,
);
let results = vec![result("a", None), result("b", None), result("c", None)];
let out = reranker.rerank_results("rust rerank", results).await;
let titles: Vec<&str> = out.iter().map(|r| r.title.as_str()).collect();
assert_eq!(titles, vec!["b", "c", "a"]);
assert!((out[0].score.unwrap() - 0.9).abs() < 1e-6);
assert!((out[1].score.unwrap() - 0.7).abs() < 1e-6);
assert!((out[2].score.unwrap() - 0.1).abs() < 1e-6);
}
#[tokio::test]
async fn test_fail_open_keeps_original_order() {
let reranker = SearchReranker::new(
Some(Arc::new(MockProvider {
fail: true,
scores: vec![],
})),
25,
);
let results = vec![result("a", None), result("b", None), result("c", None)];
let out = reranker.rerank_results("q", results).await;
let titles: Vec<&str> = out.iter().map(|r| r.title.as_str()).collect();
assert_eq!(titles, vec!["a", "b", "c"], "fail-open must keep order");
assert!(out.iter().all(|r| r.score.is_none()));
}
#[tokio::test]
async fn test_max_documents_caps_head_and_keeps_tail_in_order() {
let reranker = SearchReranker::new(
Some(Arc::new(MockProvider {
fail: false,
scores: vec![
RerankScore {
index: 1,
score: 0.8,
},
RerankScore {
index: 0,
score: 0.2,
},
],
})),
2,
);
let results = vec![
result("a", None),
result("b", None),
result("c", None),
result("d", None),
];
let out = reranker.rerank_results("q", results).await;
let titles: Vec<&str> = out.iter().map(|r| r.title.as_str()).collect();
assert_eq!(titles, vec!["b", "a", "c", "d"]);
assert!((out[0].score.unwrap() - 0.8).abs() < 1e-6);
assert!((out[1].score.unwrap() - 0.2).abs() < 1e-6);
assert!(out[2].score.is_none());
assert!(out[3].score.is_none());
}
#[tokio::test]
async fn test_out_of_range_and_missing_indices_are_defended() {
let reranker = SearchReranker::new(
Some(Arc::new(MockProvider {
fail: false,
scores: vec![
RerankScore {
index: 99,
score: 1.0,
},
RerankScore {
index: 0,
score: 0.5,
},
],
})),
25,
);
let results = vec![result("a", None), result("b", None), result("c", None)];
let out = reranker.rerank_results("q", results).await;
let titles: Vec<&str> = out.iter().map(|r| r.title.as_str()).collect();
assert_eq!(titles, vec!["a", "b", "c"]);
assert!((out[0].score.unwrap() - 0.5).abs() < 1e-6);
}
#[tokio::test]
async fn test_empty_query_short_circuits() {
let reranker = SearchReranker::new(
Some(Arc::new(MockProvider {
fail: false,
scores: vec![],
})),
25,
);
let results = vec![result("a", None), result("b", None)];
let out = reranker.rerank_results(" ", results).await;
assert_eq!(out.len(), 2);
}
#[test]
fn test_document_text_includes_description() {
let with_desc = result("Title", Some(" Some description. "));
assert_eq!(result_to_document(&with_desc), "Title. Some description.");
let blank_desc = result("Title", Some(" "));
assert_eq!(result_to_document(&blank_desc), "Title");
let no_desc = result("Title", None);
assert_eq!(result_to_document(&no_desc), "Title");
}
}