autoagents-llamacpp 0.3.7

Agent Framework for Building Autonomous Agents
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

//! Error handling and conversions for llama.cpp backend.

use autoagents_llm::error::LLMError;
use std::fmt;

/// Internal error type for llama.cpp operations.
#[derive(Debug)]
pub enum LlamaCppProviderError {
    /// Model loading failed.
    ModelLoad(String),
    /// Context creation failed.
    ContextLoad(String),
    /// Tokenization or detokenization failed.
    Tokenization(String),
    /// Inference failed.
    Inference(String),
    /// Configuration error.
    Config(String),
    /// Prompt or template error.
    Template(String),
    /// Embedding error.
    Embedding(String),
    /// Unsupported feature.
    Unsupported(String),
    /// Generic error.
    Other(String),
}

impl fmt::Display for LlamaCppProviderError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LlamaCppProviderError::ModelLoad(e) => write!(f, "Model Load Error: {}", e),
            LlamaCppProviderError::ContextLoad(e) => write!(f, "Context Load Error: {}", e),
            LlamaCppProviderError::Tokenization(e) => write!(f, "Tokenization Error: {}", e),
            LlamaCppProviderError::Inference(e) => write!(f, "Inference Error: {}", e),
            LlamaCppProviderError::Config(e) => write!(f, "Configuration Error: {}", e),
            LlamaCppProviderError::Template(e) => write!(f, "Template Error: {}", e),
            LlamaCppProviderError::Embedding(e) => write!(f, "Embedding Error: {}", e),
            LlamaCppProviderError::Unsupported(e) => write!(f, "Unsupported: {}", e),
            LlamaCppProviderError::Other(e) => write!(f, "llama.cpp Error: {}", e),
        }
    }
}

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

impl From<LlamaCppProviderError> for LLMError {
    fn from(err: LlamaCppProviderError) -> Self {
        match err {
            LlamaCppProviderError::ModelLoad(e) => {
                LLMError::ProviderError(format!("Failed to load model: {}", e))
            }
            LlamaCppProviderError::ContextLoad(e) => {
                LLMError::ProviderError(format!("Failed to create context: {}", e))
            }
            LlamaCppProviderError::Tokenization(e) => {
                LLMError::ProviderError(format!("Tokenization failed: {}", e))
            }
            LlamaCppProviderError::Inference(e) => {
                LLMError::ProviderError(format!("Inference failed: {}", e))
            }
            LlamaCppProviderError::Config(e) => {
                LLMError::InvalidRequest(format!("Invalid configuration: {}", e))
            }
            LlamaCppProviderError::Template(e) => {
                LLMError::InvalidRequest(format!("Template error: {}", e))
            }
            LlamaCppProviderError::Embedding(e) => {
                LLMError::ProviderError(format!("Embedding failed: {}", e))
            }
            LlamaCppProviderError::Unsupported(e) => LLMError::NoToolSupport(e),
            LlamaCppProviderError::Other(e) => {
                LLMError::ProviderError(format!("llama.cpp error: {}", e))
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_display() {
        let err = LlamaCppProviderError::ModelLoad("missing file".to_string());
        assert_eq!(err.to_string(), "Model Load Error: missing file");
    }

    #[test]
    fn test_error_to_llm_error() {
        let err = LlamaCppProviderError::Config("bad config".to_string());
        let llm_err: LLMError = err.into();
        assert!(llm_err.to_string().contains("Invalid configuration"));
    }
}