anthropic-tools 1.0.1

A Rust library for interacting with the Anthropic API
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Error types for the Anthropic API client.
//!
//! This module provides error handling for the library, including:
//!
//! - [`AnthropicToolError`] - Main error type for all API errors
//! - [`ErrorResponse`] - API error response structure
//! - [`ErrorDetail`] - Detailed error information
//! - [`Result`] - Type alias for `Result<T, AnthropicToolError>`
//!
//! # Error Types
//!
//! The API can return various error types:
//!
//! - `ApiKeyNotSet` - Missing API key
//! - `InvalidRequestError` - Malformed request
//! - `AuthenticationError` - Invalid API key
//! - `RateLimitError` - Too many requests
//! - `OverloadedError` - Server overloaded
//!
//! # Example
//!
//! ```rust
//! use anthropic_tools::common::errors::{AnthropicToolError, Result};
//!
//! fn validate_api_key(key: &str) -> Result<()> {
//!     if key.is_empty() {
//!         return Err(AnthropicToolError::ApiKeyNotSet);
//!     }
//!     Ok(())
//! }
//! ```

use serde::{Deserialize, Serialize};
use thiserror::Error;

/// Anthropic API error types
#[derive(Error, Debug)]
pub enum AnthropicToolError {
    #[error("API key is not set. Set ANTHROPIC_API_KEY environment variable.")]
    ApiKeyNotSet,

    #[error("Missing required field: {0}")]
    MissingRequiredField(String),

    #[error("Invalid parameter: {0}")]
    InvalidParameter(String),

    #[error("HTTP request error: {0}")]
    RequestError(#[from] request::Error),

    #[error("JSON serialization/deserialization error: {0}")]
    SerdeJsonError(#[from] serde_json::Error),

    #[error("API error ({error_type}): {message}")]
    ApiError {
        error_type: String,
        message: String,
        request_id: Option<String>,
    },

    #[error("Invalid request error: {0}")]
    InvalidRequestError(String),

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

    #[error("Permission error: {0}")]
    PermissionError(String),

    #[error("Not found error: {0}")]
    NotFoundError(String),

    #[error("Rate limit error: {0}")]
    RateLimitError(String),

    #[error("Overloaded error: {0}")]
    OverloadedError(String),

    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),
}

pub type Result<T> = std::result::Result<T, AnthropicToolError>;

/// Error response from Anthropic API
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorResponse {
    #[serde(rename = "type")]
    pub type_name: String,
    pub error: ErrorDetail,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
}

/// Error detail in API error response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorDetail {
    #[serde(rename = "type")]
    pub type_name: String,
    pub message: String,
}

impl ErrorResponse {
    /// Convert ErrorResponse to AnthropicToolError
    pub fn into_error(self) -> AnthropicToolError {
        let message = self.error.message.clone();
        let request_id = self.request_id.clone();

        match self.error.type_name.as_str() {
            "invalid_request_error" => AnthropicToolError::InvalidRequestError(message),
            "authentication_error" => AnthropicToolError::AuthenticationError(message),
            "permission_error" => AnthropicToolError::PermissionError(message),
            "not_found_error" => AnthropicToolError::NotFoundError(message),
            "rate_limit_error" => AnthropicToolError::RateLimitError(message),
            "overloaded_error" => AnthropicToolError::OverloadedError(message),
            _ => AnthropicToolError::ApiError {
                error_type: self.error.type_name,
                message,
                request_id,
            },
        }
    }
}