use crate::validate::types::Contradiction;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ReflectionCheckpoint {
NeedMore,
Relevant,
Sufficient,
Supported,
Consistent,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RarAction {
Proceed,
ExpandQuery { new_query: String },
ReformulateQuery { reason: String, new_query: String },
FetchMore { urls: Vec<String> },
RemoveUnsupported { claim_ids: Vec<String> },
FlagContradictions { contradictions: Vec<Contradiction> },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RarIterationResult {
pub iteration: usize,
pub checkpoint: ReflectionCheckpoint,
pub action: RarAction,
pub quality_before: f64,
pub quality_after: f64,
}
#[derive(Debug, Clone)]
pub struct RarConfig {
pub max_loops: usize,
pub min_relevant_ratio: f64,
pub min_sufficiency_score: f64,
pub min_consistency_score: f64,
pub min_results: usize,
}
impl Default for RarConfig {
fn default() -> Self {
Self {
max_loops: 3,
min_relevant_ratio: 0.5,
min_sufficiency_score: 0.4,
min_consistency_score: 0.5,
min_results: 3,
}
}
}
#[derive(Debug, Clone)]
pub struct RarState {
pub query: String,
pub total_results: usize,
pub relevant_count: usize,
pub sufficiency_score: f64,
pub support_ratio: f64,
pub consistency_score: f64,
pub unsupported_claims: Vec<String>,
pub contradictions: Vec<Contradiction>,
pub candidate_urls: Vec<String>,
pub low_relevance_terms: Vec<String>,
}
impl RarState {
pub fn overall_quality(&self) -> f64 {
let relevance = self.relevant_count as f64 / self.total_results.max(1) as f64;
(relevance + self.sufficiency_score + self.consistency_score) / 3.0
}
}
#[derive(Default)]
pub struct RarEngine {
config: RarConfig,
}
impl RarEngine {
pub fn new(config: RarConfig) -> Self {
Self { config }
}
pub fn evaluate(&self, state: &RarState, iteration: usize) -> RarIterationResult {
if iteration >= self.config.max_loops {
return RarIterationResult {
iteration,
checkpoint: ReflectionCheckpoint::Consistent,
action: RarAction::Proceed,
quality_before: state.overall_quality(),
quality_after: state.overall_quality(),
};
}
if state.total_results < self.config.min_results {
let new_query = Self::expand_query(&state.query);
return RarIterationResult {
iteration,
checkpoint: ReflectionCheckpoint::NeedMore,
action: RarAction::ExpandQuery { new_query },
quality_before: state.overall_quality(),
quality_after: state.overall_quality(),
};
}
let relevant_ratio = state.relevant_count as f64 / state.total_results.max(1) as f64;
if relevant_ratio < self.config.min_relevant_ratio {
let new_query = Self::reformulate(&state.query, &state.low_relevance_terms);
return RarIterationResult {
iteration,
checkpoint: ReflectionCheckpoint::Relevant,
action: RarAction::ReformulateQuery {
reason: format!(
"Only {:.0}% relevant (need {:.0}%)",
relevant_ratio * 100.0,
self.config.min_relevant_ratio * 100.0
),
new_query,
},
quality_before: relevant_ratio,
quality_after: relevant_ratio,
};
}
if state.sufficiency_score < self.config.min_sufficiency_score {
return RarIterationResult {
iteration,
checkpoint: ReflectionCheckpoint::Sufficient,
action: RarAction::FetchMore {
urls: state.candidate_urls.clone(),
},
quality_before: state.sufficiency_score,
quality_after: state.sufficiency_score,
};
}
if !state.unsupported_claims.is_empty() {
return RarIterationResult {
iteration,
checkpoint: ReflectionCheckpoint::Supported,
action: RarAction::RemoveUnsupported {
claim_ids: state.unsupported_claims.clone(),
},
quality_before: state.support_ratio,
quality_after: 1.0,
};
}
if state.consistency_score < self.config.min_consistency_score {
return RarIterationResult {
iteration,
checkpoint: ReflectionCheckpoint::Consistent,
action: RarAction::FlagContradictions {
contradictions: state.contradictions.clone(),
},
quality_before: state.consistency_score,
quality_after: state.consistency_score,
};
}
RarIterationResult {
iteration,
checkpoint: ReflectionCheckpoint::Consistent,
action: RarAction::Proceed,
quality_before: state.overall_quality(),
quality_after: state.overall_quality(),
}
}
fn expand_query(query: &str) -> String {
format!("{query} overview")
}
fn reformulate(query: &str, _low_terms: &[String]) -> String {
let words: Vec<&str> = query
.split_whitespace()
.filter(|w| w.len() > 3)
.take(5)
.collect();
if words.is_empty() {
query.to_string()
} else {
words.join(" ")
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn good_state() -> RarState {
RarState {
query: "what is Rust".into(),
total_results: 10,
relevant_count: 8,
sufficiency_score: 0.8,
support_ratio: 1.0,
consistency_score: 0.9,
unsupported_claims: vec![],
contradictions: vec![],
candidate_urls: vec![],
low_relevance_terms: vec![],
}
}
#[test]
fn good_state_proceeds() {
let engine = RarEngine::default();
let r = engine.evaluate(&good_state(), 0);
assert!(matches!(r.action, RarAction::Proceed));
}
#[test]
fn insufficient_results_expands() {
let engine = RarEngine::default();
let mut state = good_state();
state.total_results = 1;
state.relevant_count = 1;
let r = engine.evaluate(&state, 0);
assert!(matches!(r.action, RarAction::ExpandQuery { .. }));
assert_eq!(r.checkpoint, ReflectionCheckpoint::NeedMore);
}
#[test]
fn low_relevance_reformulates() {
let engine = RarEngine::default();
let mut state = good_state();
state.total_results = 10;
state.relevant_count = 2;
let r = engine.evaluate(&state, 0);
assert!(matches!(r.action, RarAction::ReformulateQuery { .. }));
}
#[test]
fn max_loops_respected() {
let engine = RarEngine::new(RarConfig {
max_loops: 2,
..Default::default()
});
let mut state = good_state();
state.total_results = 1;
let r = engine.evaluate(&state, 2);
assert!(matches!(r.action, RarAction::Proceed));
}
#[test]
fn unsupported_claims_removed() {
let engine = RarEngine::default();
let mut state = good_state();
state.unsupported_claims = vec!["claim_1".into()];
let r = engine.evaluate(&state, 0);
assert!(matches!(r.action, RarAction::RemoveUnsupported { .. }));
}
#[test]
fn low_consistency_flags_contradictions() {
let engine = RarEngine::default();
let mut state = good_state();
state.consistency_score = 0.2;
let r = engine.evaluate(&state, 0);
assert!(matches!(r.action, RarAction::FlagContradictions { .. }));
}
}