aineed-core 0.1.1

Core library for the aineed AI assistant tool
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

use std::fmt;
use std::io;
use reqwest::StatusCode;

#[derive(Debug)]
pub enum AiNeedError {
    IoError(io::Error),
    ConfigError(String),
    MissingApiKey {
        provider: String,
        endpoint: String,
        quota_reset: Option<String>,
    },
    InvalidApiKey {
        provider: String,
        endpoint: String,
        quota_reset: Option<String>,
    },
    QuotaExceeded {
        provider: String,
        endpoint: String,
        quota_reset: Option<String>,
    },
    UnsupportedModel {
        provider: String,
        model: String,
        supported_models: Vec<String>,
    },
    ApiError {
        provider: String,
        endpoint: String,
        status: u16,
        message: String,
    },
    RequestError {
        status: StatusCode,
        message: String,
        details: Option<String>,
    },
}

impl fmt::Display for AiNeedError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AiNeedError::IoError(err) => write!(f, "IO error: {}", err),
            AiNeedError::ConfigError(msg) => write!(f, "Configuration error: {}", msg),
            AiNeedError::MissingApiKey { provider, endpoint, quota_reset } => {
                write!(f, "Missing API key for {} ({})", provider, endpoint)?;
                if let Some(reset) = quota_reset {
                    write!(f, " - Quota resets at {}", reset)?;
                }
                Ok(())
            },
            AiNeedError::InvalidApiKey { provider, endpoint, quota_reset } => {
                write!(f, "Invalid API key for {} ({})", provider, endpoint)?;
                if let Some(reset) = quota_reset {
                    write!(f, " - Quota resets at {}", reset)?;
                }
                Ok(())
            },
            AiNeedError::QuotaExceeded { provider, endpoint, quota_reset } => {
                write!(f, "Quota exceeded for {} ({})", provider, endpoint)?;
                if let Some(reset) = quota_reset {
                    write!(f, " - Quota resets at {}", reset)?;
                }
                Ok(())
            },
            AiNeedError::UnsupportedModel { provider, model, supported_models } => {
                write!(f, "Unsupported model '{}' for provider {}. Supported models: {}", 
                    model, provider, supported_models.join(", "))
            },
            AiNeedError::ApiError { provider, endpoint, status, message } => {
                write!(f, "API error from {} ({}): {} - {}", provider, endpoint, status, message)
            },
            AiNeedError::RequestError { status, message, details } => {
                if let Some(detail) = details {
                    write!(f, "Request error ({}): {} - {}", status, message, detail)
                } else {
                    write!(f, "Request error ({}): {}", status, message)
                }
            },
        }
    }
}

impl std::error::Error for AiNeedError {}

impl From<io::Error> for AiNeedError {
    fn from(err: io::Error) -> Self {
        AiNeedError::IoError(err)
    }
}