rypsok 0.10.0

Headless meta-search service for AI agents, served over the Model Context Protocol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Live driver checks (REQ-TEST-003): one fixed query per driver against
//! the real provider, within its terms. Ignored by default; the scheduled
//! workflow runs them with `--ignored`. They report format drift and never
//! gate.

use rypsok_core::CancellationToken;
use rypsok_core::config::{Config, SafeSearch};
use rypsok_core::engine::EngineRequest;
use rypsok_core::engine::registry::Registry;
use rypsok_core::model::{Category, Language};

fn request(query: &str) -> EngineRequest {
    let mut request = EngineRequest::new(query, Language::new("en").unwrap());
    request.max_results = 5;
    request.safe_search = SafeSearch::Moderate;
    request
}

fn config(text: &str) -> Config {
    let contact = std::env::var("RYPSOK_LIVE_CONTACT")
        .unwrap_or_else(|_| "https://github.com/nabbisen/rypsok/issues".into());
    let config = Config::parse(&format!(
        "config_version = 1\n[service]\nuser_agent_contact = \"{contact}\"\n{text}"
    ))
    .unwrap();
    config.validate().unwrap();
    config
}

/// REQ-TEST-003: the Wikipedia driver parses a real response.
#[tokio::test]
#[ignore = "reaches the real provider; run by the scheduled workflow"]
async fn live_wikipedia_search() {
    let config = config("[engines.wikipedia]\ntype = \"wikipedia\"\ncategories = [\"general\"]\n");
    let registry = Registry::build(&config, None, true);
    let engine = registry
        .select(Category::General, 1)
        .into_iter()
        .next()
        .expect("wikipedia active");
    let driver = engine.driver.as_deref().unwrap();
    let response = driver
        .search(
            &request("Rust (programming language)"),
            CancellationToken::new(),
        )
        .await
        .expect("wikipedia answers");
    assert!(!response.results.is_empty(), "wikipedia returned no result");
    assert!(
        response.results[0]
            .url
            .starts_with("https://en.wikipedia.org/wiki/")
    );
}

/// REQ-TEST-003: the Brave driver parses a real response; skipped and
/// reported without the repository secret.
#[tokio::test]
#[ignore = "reaches the real provider; run by the scheduled workflow"]
async fn live_brave_search() {
    if std::env::var("BRAVE_API_KEY")
        .map(|k| k.trim().is_empty())
        .unwrap_or(true)
    {
        use std::io::Write;
        let _ = writeln!(
            std::io::stderr(),
            "live_brave_search: skipped, BRAVE_API_KEY is not set"
        );
        return;
    }
    let config = config(
        "[engines.brave]\ntype = \"brave\"\ncategories = [\"general\"]\napi_key_env = \"BRAVE_API_KEY\"\n",
    );
    let registry = Registry::build(&config, None, true);
    let engine = registry
        .select(Category::General, 1)
        .into_iter()
        .next()
        .expect("brave active");
    let driver = engine.driver.as_deref().unwrap();
    let response = driver
        .search(
            &request("rust programming language"),
            CancellationToken::new(),
        )
        .await
        .expect("brave answers");
    assert!(!response.results.is_empty(), "brave returned no result");
}

/// REQ-TEST-003 and RFC 015: the DuckDuckGo HTML driver against the real
/// endpoint with the honest User-Agent. A `blocked` answer is the
/// provider's decision and is reported as such, never worked around
/// (REQ-ENG-014).
#[tokio::test]
#[ignore = "reaches the real provider; run by the scheduled workflow"]
async fn live_duckduckgo_search() {
    let config = config(
        "[scraping]\nenabled = true\n[engines.ddg]\ntype = \"duckduckgo\"\ncategories = [\"general\"]\n",
    );
    let registry = Registry::build(&config, None, true);
    let engine = registry
        .select(Category::General, 1)
        .into_iter()
        .next()
        .expect("duckduckgo active");
    let driver = engine.driver.as_deref().unwrap();
    match driver
        .search(
            &request("Rust programming language"),
            CancellationToken::new(),
        )
        .await
    {
        Ok(response) => {
            assert!(
                !response.results.is_empty(),
                "duckduckgo returned no result"
            );
            assert!(response.results[0].url.starts_with("http"));
        }
        Err(error) => panic!(
            "duckduckgo answered {:?}: the provider refuses the honest agent or its format drifted",
            error.class
        ),
    }
}