websearch 0.1.1

High-performance Rust library and CLI tool for multi-provider web search. Supports Google, ArXiv, DuckDuckGo, Tavily AI, and more with aggregation strategies.
Documentation 
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

//! Error types for the search SDK

use thiserror::Error;

/// Result type alias for search operations
pub type SearchResult<T> = std::result::Result<T, SearchError>;

/// Comprehensive error types for search operations
#[derive(Error, Debug, Clone)]
pub enum SearchError {
    /// HTTP request failed
    #[error("HTTP request failed: {message}")]
    HttpError {
        message: String,
        status_code: Option<u16>,
        response_body: Option<String>,
    },

    /// Invalid input parameters
    #[error("Invalid input: {0}")]
    InvalidInput(String),

    /// Provider-specific error
    #[error("Provider error: {0}")]
    ProviderError(String),

    /// Configuration error
    #[error("Configuration error: {0}")]
    ConfigError(String),

    /// Parsing error (JSON, XML, HTML)
    #[error("Parsing error: {0}")]
    ParseError(String),

    /// Timeout error
    #[error("Request timed out after {timeout_ms}ms")]
    Timeout { timeout_ms: u64 },

    /// Rate limit exceeded
    #[error("Rate limit exceeded: {0}")]
    RateLimit(String),

    /// Authentication failed
    #[error("Authentication failed: {0}")]
    AuthenticationError(String),

    /// Generic error for unhandled cases
    #[error("Search error: {0}")]
    Other(String),
}

impl From<reqwest::Error> for SearchError {
    fn from(error: reqwest::Error) -> Self {
        if error.is_timeout() {
            SearchError::Timeout {
                timeout_ms: 15000, // Default timeout
            }
        } else if error.is_status() {
            let status_code = error.status().map(|s| s.as_u16());
            let message = error.to_string();

            // Determine if it's an auth error based on status code
            if let Some(401 | 403) = status_code {
                SearchError::AuthenticationError(message)
            } else if let Some(429) = status_code {
                SearchError::RateLimit(message)
            } else {
                SearchError::HttpError {
                    message,
                    status_code,
                    response_body: None,
                }
            }
        } else {
            SearchError::HttpError {
                message: error.to_string(),
                status_code: None,
                response_body: None,
            }
        }
    }
}

impl From<serde_json::Error> for SearchError {
    fn from(error: serde_json::Error) -> Self {
        SearchError::ParseError(format!("JSON parsing failed: {error}"))
    }
}

impl From<url::ParseError> for SearchError {
    fn from(error: url::ParseError) -> Self {
        SearchError::InvalidInput(format!("Invalid URL: {error}"))
    }
}

impl From<std::io::Error> for SearchError {
    fn from(error: std::io::Error) -> Self {
        SearchError::Other(format!("IO error: {error}"))
    }
}